ఉదాహరణ 01:
టెర్మినల్ కన్సోల్ అప్లికేషన్‌ను ప్రారంభించడం ద్వారా C++లో __FILE__ మాక్రో యొక్క మొదటి ఉదాహరణను తీసుకుందాం. మీరు అలా చేయడానికి “Ctrl+Alt+T” సత్వరమార్గాన్ని ఉపయోగిస్తూ ఉండవచ్చు. మీరు షార్ట్‌కట్ కీని మరచిపోయినట్లయితే, షెల్‌ను తెరవడానికి మరొక మార్గం మెను కార్యాచరణ ప్రాంతాన్ని ఉపయోగించడం. మీ స్క్రీన్‌పై టెర్మినల్ కన్సోల్ ప్రారంభించబడిన తర్వాత, దానిలో కోడ్ చేయడానికి కొత్త c++ ఫైల్‌ని సృష్టించడానికి ప్రయత్నించండి. దిగువ జోడించిన చిత్రంలో చూపిన విధంగా ఒక సాధారణ “స్పర్శ” ప్రశ్నతో ఫైల్‌ను సృష్టించవచ్చు. కొత్తగా సృష్టించబడిన ఫైల్ పేరు తప్పనిసరిగా “టచ్” కీవర్డ్‌తో ఇవ్వాలి.
మీ ఉబుంటు 20.04 లైనక్స్ సిస్టమ్‌లో కొత్తగా సృష్టించిన ఫైల్‌లను కోడింగ్ చేయడానికి మరియు తెరవడానికి కొన్ని ఎడిటర్ తప్పనిసరిగా ఇన్‌స్టాల్ చేయబడి ఉండాలి. Linux వినియోగదారులలో విస్తృతంగా తెలిసిన అత్యంత సిఫార్సు చేయబడిన సంపాదకులు GNU నానో మరియు Vim ఎడిటర్. అలా కాకుండా, గతంలో పేర్కొన్న రెండు ఎడిటర్‌లు పని చేయని సందర్భంలో కూడా టెక్స్ట్ ఎడిటర్‌ని ఉపయోగించవచ్చు. కాబట్టి, మేము ఇప్పటికే GNU నానో ఎడిటర్‌ను ఇన్‌స్టాల్ చేసాము. కాబట్టి, కోడ్‌ని రూపొందించడానికి ఫైల్‌ను తెరవడానికి మరియు సవరించడానికి మేము దీన్ని ఉపయోగిస్తాము. ఎడిటర్ పని చేయడానికి ఫైల్ పేరుతో పాటు “నానో” కీవర్డ్‌ని ఉపయోగించండి.
ఇప్పుడు, కొత్తగా సృష్టించబడిన C++ ఫైల్ macro.cc ఎడిటర్‌లో కోడింగ్ కోసం సిద్ధంగా ఉంది. __FILE__ మాక్రో యొక్క పనిని చూడడానికి ఈ కథనాన్ని అమలు చేస్తున్నందున C++ కోడ్‌ని అమలు చేయడం ప్రారంభిద్దాం. మేము దాని ఎగువన ప్రామాణిక ఇన్‌పుట్-అవుట్‌పుట్ హెడర్‌ను జోడించడం ద్వారా మా C++ కోడ్‌ని ప్రారంభించాము. 'చేర్చండి' అనే కీవర్డ్ అలా చేయడానికి హాష్ గుర్తుతో ఉపయోగించబడింది. ఈ హెడర్ లేకుండా, C++ కోడ్ యొక్క ఇన్‌పుట్ మరియు అవుట్‌పుట్ కంపైల్ మరియు ఎగ్జిక్యూషన్ తర్వాత కన్సోల్‌లో పని చేయదు.
ప్రధాన() పద్ధతి మా కోడ్ యొక్క ప్రాథమిక స్తంభం, ఎందుకంటే అమలు దాని నుండి మొదలై దానిలో ముగుస్తుంది. ప్రధాన () పద్ధతిలో, అసలు పని చేయబడుతుంది. __FILE__ మాక్రో యొక్క కార్యాచరణను వివరించడానికి మేము మా ప్రధాన() పద్ధతిలో ఒకే లైన్ కోడ్‌ని ఉపయోగిస్తున్నాము. కాబట్టి, printf స్టేట్‌మెంట్ ఇక్కడ ఉపయోగించబడింది, రెండు విలువలను ఆర్గ్యుమెంట్‌లుగా తీసుకుంటుంది, అంటే, ఫైల్ పేరు మరియు స్థూల ఫంక్షన్‌ను తీసుకునే స్ట్రింగ్.
ప్రస్తుత ఫైల్ పాత్ లేదా దాని పేరును పొందేందుకు __FILE__ మాక్రో ఇక్కడ ఉపయోగించబడుతుంది. ఫైల్ యొక్క ప్రస్తుత పాత్‌ను లేదా స్ట్రింగ్‌లో దాని పేరును ప్రింట్ చేయడానికి “%S” ఉపయోగించబడుతుంది. మీరు 'Ctrl+S' సత్వరమార్గం సహాయంతో అమలు చేయడానికి ముందు మీ కోడ్‌ను తప్పనిసరిగా సేవ్ చేయాలి. ఇప్పుడు కోడ్ సేవ్ చేయబడింది, “Ctrl+X” షార్ట్‌కట్‌ని ఉపయోగించి షెల్ టెర్మినల్‌కి తిరిగి రావడానికి ప్రయత్నించండి.
మేము __FILE__ మాక్రో కోసం C++ కోడ్‌ని పూర్తి చేసినందున, C++ కోడ్ సంకలనాన్ని ప్రారంభిద్దాం. సంకలనం కోసం, C++ కోడ్‌ను కంపైల్ చేయడానికి మేము ఇప్పటికే g++ కంపైలర్‌ని ఇన్‌స్టాల్ చేసాము. కాబట్టి, 'macro.cc' ఫైల్‌ను కంపైల్ చేయడానికి టెర్మినల్‌లో g++ కంపైలర్ ఉపయోగించబడింది. సంకలనం చేసిన తర్వాత, ఇది ఏమీ ఇవ్వదు, ఇది Macro.cc ఫైల్‌లో C++ కోడ్ అర్థపరంగా సరైనదని సూచిస్తుంది. సంకలనం తర్వాత, కోడ్ అమలు కోసం మలుపులు వస్తాయి. కోడ్ ఫైల్‌ను అమలు చేయడానికి, మేము “./.aout” సాధారణ ప్రశ్నను ఉపయోగిస్తాము. macro.cc ఫైల్‌ను రన్ చేసిన తర్వాత, ప్రతిఫలంగా మనకు ఫైల్ పేరు వచ్చింది. ఈ విధంగా C++ __FILE__ మాక్రో పని చేస్తుంది.
ఉదాహరణ 02:
ఉబుంటు 20.04 సిస్టమ్‌లోని C++ __FILE__ మాక్రో యొక్క కార్యాచరణను పరిశీలించడానికి లోతుగా వెళ్లడానికి మరొక ఉదాహరణను చూద్దాం. C++ __FILE__ మాక్రో పేర్కొనబడిన ఫైల్ యొక్క ఫైల్ పాత్‌ను పొందేందుకు ఉపయోగించినప్పుడు అది ఎలా పనిచేస్తుందో మనం చూశాము.
ఇప్పుడు, మేము ప్రస్తుతం పని చేస్తున్న ఫైల్ కాకుండా ఫైల్ పాత్ లేదా ఫైల్ పేరును పొందడానికి C++ __FILE__ మాక్రోని ఉపయోగిస్తాము. కాబట్టి, మేము కోడ్‌ను నవీకరించడానికి GNU నానో ఎడిటర్‌లో macro.cc ఫైల్‌ని తెరిచాము. మేము చేర్చబడిన కీవర్డ్‌తో ప్రామాణిక ఇన్‌పుట్-అవుట్‌పుట్ హెడర్‌ను జోడించాము మరియు పూర్ణాంకం రిటర్న్ రకంతో మెయిన్() ఫంక్షన్‌ను ప్రారంభించాము.
ప్రధాన() పద్ధతిలో, మేము ప్రస్తుతం పని చేస్తున్న ప్రస్తుత ఫైల్ పాత్‌ను పొందడానికి మొదటి ప్రింట్ స్టేట్‌మెంట్ పాతది వలె ఉంటుంది. ఆ తర్వాత, మేము మరొక ఫైల్ పేరుతో #line కీవర్డ్‌ని ఉపయోగించాము, అనగా, తదుపరి వరుస లైన్‌లో “new.txt”. మేము దాని పేరు లేదా మార్గాన్ని పొందుతున్న ప్రస్తుత ఫైల్ కాకుండా వేరే ఫైల్‌ను పేర్కొనడం. C++ __FILE__ మాక్రో సహాయంతో “new.txt” ఫైల్ యొక్క పాత్‌ను ప్రింట్ చేయడానికి తదుపరి printf స్టేట్‌మెంట్ ఉపయోగించబడింది. కంపైలేషన్ సమయంలో ఎలాంటి అసౌకర్యం కలగకుండా ఉండేందుకు మీ కొత్తగా అప్‌డేట్ చేసిన కోడ్‌ను సేవ్ చేయండి. అలా చేయడానికి “Ctrl+S” ఉపయోగించండి.
నవీకరించబడిన ఫైల్‌ను సేవ్ చేసిన తర్వాత, మీ కీబోర్డ్ నుండి “Ctrl+X” ద్వారా దాన్ని నిష్క్రమించండి. ఇప్పుడు, మేము షెల్ స్క్రీన్‌పైకి తిరిగి వచ్చాము.
నవీకరించబడిన ఫైల్‌ను కంపైల్ చేద్దాం. macro.cc ఫైల్ పేరుతో అలా చేయడానికి g++ కంపైలర్‌ని ఉపయోగించండి. విజయవంతమైన సంకలనం తర్వాత, కన్సోల్‌లో “./a.out” ఆదేశంతో కోడ్‌ను అమలు చేయండి. అవుట్‌పుట్ ముందుగా ప్రస్తుత ఫైల్‌కు పాత్‌ను చూపుతుంది, తర్వాత ఇతర ఫైల్‌కి మార్గం, “new.txt” షెల్ స్క్రీన్‌పై ప్రదర్శించబడుతుంది. షెల్‌పై ఫైల్ పాత్‌ను ప్రదర్శించడానికి __FILE__ మాక్రోను ఉపయోగించడం ఎంత సులభమో చూడండి.
ఉదాహరణ 03:
C++లో __LINE__ మాక్రోతో పాటు __FILE__ మాక్రోని చూద్దాం. __LINE__ మాక్రో మాక్రో ఉపయోగించబడిన ఫైల్ యొక్క లైన్ నంబర్‌ను ప్రదర్శిస్తుంది. కాబట్టి, ఒకే ఫైల్‌ని తెరిచి, రెండు printf స్టేట్‌మెంట్‌లను నవీకరించండి. C++ __LINE__ మాక్రో కంటే ముందు, మేము C++ __LINE__ మాక్రోని జోడించాము. ఈ __LINE__macro __FILE__ ముందుగా వచ్చే ప్రస్తుత ఫైల్ యొక్క లైన్ నంబర్‌ను పొందుతోంది. మేము ఇప్పటికే కోడ్‌లో ఫైల్ పేరుతో లైన్ నంబర్‌ను పేర్కొన్నందున తదుపరి __LINE__ మాక్రో ఇతర ఫైల్ యొక్క మొదటి లైన్ నంబర్‌ను పొందుతుంది.
ఫైల్‌ను సేవ్ చేసి, నిష్క్రమించిన తర్వాత, మేము షెల్ టెర్మినల్‌కు తిరిగి వచ్చాము. మేము C++ macro.cc ఫైల్ కోడ్‌ను కంపైల్ చేయడానికి అదే g++ కమాండ్‌ని ఉపయోగిస్తున్నాము. విజయవంతమైన సంకలనం అమలు ఆదేశానికి దారి తీస్తుంది. ఇప్పుడు అలా చేయడానికి ఇక్కడ “./a.out” కమాండ్ ఉపయోగించబడుతుంది. మొదటి ఫైల్, అంటే, లైన్ 3లోని ప్రస్తుత ఫైల్, __FILE__ మాక్రో కోడ్‌లో పేర్కొన్న ఇతర ఫైల్‌లోని మొదటి లైన్‌లో ఉందని అమలు మాకు చెబుతుంది.
ముగింపు:
ఈ కథనం మాక్రోల నిర్వచనాన్ని కలిగి ఉంది మరియు ఉబుంటు 20.04 సిస్టమ్‌లో C++ __FILE__ మాక్రో వినియోగాన్ని చర్చిస్తుంది. C++ __LINE__ మాక్రో మరింతగా C++ __FILE__ మాక్రో పనిని వివరించడానికి కొన్ని ఉదాహరణలలో కూడా చర్చించబడింది. మొత్తానికి, ఈ కథనం C++ __FILE__macroని ఉత్తమంగా అందించడంలో మీకు సహాయపడుతుందని మేము ఆశిస్తున్నాము.