ఫైల్ ఎల్లప్పుడూ విభిన్న రకాల కంటెంట్‌తో రూపొందించబడింది: ఇది సాధారణ టెక్స్ట్ ఫైల్ అయినా, ప్రోగ్రామ్ కోడ్ ఫైల్ అయినా లేదా ఏదైనా మేక్‌ఫైల్ అయినా. ఏదైనా ఫైల్ యొక్క కంటెంట్ రకం దానిని ప్రత్యేకంగా చేస్తుంది మరియు ఫైల్‌ల యొక్క ఇతర ఫార్మాట్ నుండి వేరు చేస్తుంది. అలాగే, makefile దాని పనిని సరిగ్గా నిర్వహించడానికి వివిధ అంశాలను ఉపయోగించే నియమాలను కలిగి ఉంటుంది. ఆ అంశాల నుండి, వైల్డ్కార్డ్ మరియు ఫోరీచ్‌లు ప్రత్యేకమైనవి మరియు అదనపు వాటిని ప్రదర్శించడానికి అవసరం. ఈ గైడ్‌లో, వైల్డ్‌కార్డ్‌లు మరియు ఫోర్చ్‌లను మేక్‌ఫైల్‌లో ఉపయోగించినప్పుడు వాటి శక్తిని మేము చర్చిస్తాము.
మేక్‌ఫైల్‌లో వైల్డ్‌కార్డ్‌లు
సాధారణంగా, వైల్డ్కార్డ్ అనేది ఊహించలేని కారకంగా మరియు పరిస్థితిని ఏ విధంగానైనా మార్చగలదని అంటారు. మేక్‌ఫైల్‌లోని వైల్డ్‌కార్డ్‌లు ప్రస్తుత వర్కింగ్ డైరెక్టరీ నుండి సాధ్యమయ్యే అన్ని నమూనాలను గుర్తించే బోనస్‌ని నిర్వహించడానికి ఉపయోగించబడతాయి, అది ఫైల్ లేదా ఏదైనా ఫోల్డర్. ఈ సోర్స్ ఫైల్‌లు ఏ రకంగానైనా ఉండవచ్చు.
మేక్‌ఫైల్‌లో వైల్డ్‌కార్డ్‌ని ఉపయోగించడానికి, మీరు “*” లేదా “?” అనే నక్షత్రాన్ని అనుసరించే “వైల్డ్కార్డ్” కీవర్డ్‌ని ఉపయోగించాలి. సైన్ మరియు డాట్ ద్వారా కనెక్ట్ చేయబడిన ఫైల్ ఎక్స్‌టెన్షన్. మీరు '?'ని కూడా ఉపయోగించవచ్చు. ఒకే అక్షరం కోసం శోధించడానికి సైన్ ఇన్ చేయండి మరియు ఎన్ని అక్షరాలతో సరిపోలడానికి “*”. ఈ మొత్తం నిర్మాణాన్ని బ్రాకెట్లలో మరియు '$' గుర్తులో ఉపయోగించాలి. ఉదాహరణకు, వైల్డ్కార్డ్ ద్వారా దాని విలువ ఫైల్‌ను పొందే “SRCS” వేరియబుల్‌ని మేము ప్రకటిస్తాము. ఈ వైల్డ్కార్డ్ అన్ని ఫైల్‌ల చివర “cpp” నమూనాతో వెతుకుతుంది.
మేక్‌ఫైల్‌లో ఫోర్చ్
makefile యొక్క foreach ఫంక్షన్ ఖచ్చితంగా ప్రోగ్రామింగ్ భాషలలో foreach లూప్ వలె పని చేస్తుంది - జాబితాలోని అంశాలపై మళ్ళించండి. మేక్‌ఫైల్‌లోని ఫోర్చ్ ఫంక్షన్ జాబితా యొక్క ప్రతి అంశంపై నిర్దిష్ట చర్యను చేస్తుంది. ఈ మూలకం వేరియబుల్ లేదా ఏదైనా సోర్స్ ఫైల్ కావచ్చు. ఉదాహరణకు, మేము మూడు సోర్స్ ఫైల్‌ల జాబితాను కలిగి ఉన్న SOURCES వేరియబుల్ ద్వారా makefileలో foreach ఫంక్షన్ యొక్క సింటాక్స్‌ను విశదీకరించాము. మూడు ఆబ్జెక్ట్ ఫైల్‌ల కోసం ఒకే పేరుని సృష్టించడానికి ఫోర్చ్ ఫంక్షన్ ఈ సోర్స్ వేరియబుల్‌ని ఉపయోగిస్తుంది, సోర్స్ ఫైల్‌ల జాబితాను మళ్లీ మళ్లీ మరొక 'OBJECTS' వేరియబుల్‌లో సేవ్ చేస్తుంది. మళ్ళించిన తర్వాత ప్రతి C ఫైల్‌కి ఆబ్జెక్ట్ ఫైల్‌ను సృష్టించడానికి మేక్‌ఫైల్ నియమాన్ని ఎలా ఉపయోగించవచ్చో చివరి రెండు పంక్తులు చూపుతాయి.
మూలాధారాలు := file1.c file2.c file3.c
వస్తువులు := $ ( foreach src,$ ( మూలాలు ) ,$ ( src:.c=.o ) )
$OBJECTS : % .ఓ: % .సి
$ ( CC ) $ ( CFLAGS ) -సి $ < -ఓ $ @
ఉదాహరణ 1: వైల్డ్‌కార్డ్‌లను ఉపయోగించడం
వైల్డ్‌కార్డ్‌లు మరియు ఫోర్చ్ ఫంక్షన్‌ల యొక్క ఇలస్ట్రేషన్ మరియు పనిని ప్రదర్శించడానికి, మేము C++ ఫైల్‌ను పరిచయం చేస్తాము. ఈ “salary.cpp” ఫైల్ ఇన్‌పుట్ మరియు అవుట్‌పుట్ స్ట్రీమ్‌లను సజావుగా ఉపయోగించుకోవడానికి “iostream” హెడర్‌ని ఉపయోగించడంతో ప్రారంభించబడింది. ప్రధాన పద్ధతి పూర్ణాంకాల రకం యొక్క వేరియబుల్ “s” మరియు రన్‌టైమ్‌లో ఇన్‌పుట్ విలువను అడగడానికి “కౌట్” స్టేట్‌మెంట్‌ను ప్రకటిస్తుంది. “cin” ప్రామాణిక ఇన్‌పుట్ స్ట్రీమ్ రన్‌టైమ్‌లో వినియోగదారు నుండి విలువను పొందుతుంది మరియు దానిని వేరియబుల్ “s”లో సేవ్ చేస్తుంది. 'కౌట్' కన్సోల్ స్క్రీన్‌పై వినియోగదారు ఇన్‌పుట్ చేసిన విలువను ప్రదర్శిస్తుంది.
#నేమ్‌స్పేస్ stdని ఉపయోగించడం;
పూర్ణాంక ప్రధాన ( ) {
int లు;
కోట్ << 'జీతం నమోదు చేయండి:' ;
ఆహారపు >> లు;
కోట్ << ' \n జీతం: ' << లు << endl;
తిరిగి 0 ;
}
మేము C++ కోసం కంపైలర్‌ను నిర్వచించే “CXX” వేరియబుల్‌తో మేక్‌ఫైల్‌ను ప్రారంభిస్తాము మరియు CXXFLAGS వేరియబుల్ C++ కంపైలర్ కోసం ఫ్లాగ్‌లను కలిగి ఉంటుంది. ఎక్జిక్యూటబుల్ వేరియబుల్ ఎక్జిక్యూటబుల్ “హలో” ఫైల్ పేరును కలిగి ఉంటుంది, అది మేక్‌ఫైల్ అమలు తర్వాత ఉత్పత్తి అవుతుంది. SRCS వేరియబుల్ “.cpp”తో ముగిసే ఏదైనా నమూనాను శోధించడానికి వైల్డ్కార్డ్ “*”ని ఉపయోగించి ప్రస్తుత డైరెక్టరీ నుండి అన్ని C++ ఫైల్‌లను పొందుతుంది. OBJS వేరియబుల్ SRCS వేరియబుల్ ఉపయోగించి సృష్టించబడే ఆబ్జెక్ట్ ఫైల్‌ల పేర్లను కలిగి ఉంటుంది, “cpp” పొడిగింపును “o”తో భర్తీ చేస్తుంది. డిఫాల్ట్ “అన్ని” లక్ష్యం మేక్‌ఫైల్‌ను నిర్మిస్తుంది మరియు ఇది ఎక్జిక్యూటబుల్ వేరియబుల్‌పై ఆధారపడి ఉంటుంది.
మొదటి నియమం 'OBJS' వేరియబుల్ ద్వారా రూపొందించబడిన ఫైల్ పేర్లను ఉపయోగించి OBJS వేరియబుల్ (ఆబ్జెక్ట్ ఫైల్‌ల పేర్లు) ఆబ్జెక్ట్ ఫైల్‌పై ఆధారపడిన లక్ష్య 'హలో' ఫైల్‌ను సృష్టిస్తుంది. రెండవ makefile నియమం C++ కోడ్ ఫైల్‌ను కంపైల్ చేసిన తర్వాత C++ ఫైల్‌పై ఆధారపడిన “.o” పొడిగింపుతో ఆబ్జెక్ట్ ఫైల్‌ను ఉత్పత్తి చేస్తుంది. ఇక్కడ, '%' అనేది 'cpp'తో ముగిసే ఏదైనా నమూనా యొక్క ఫైల్ పేర్ల కోసం శోధించడానికి వైల్డ్ కార్డ్. చివరికి, “-f” ఫ్లాగ్‌ని ఉపయోగించి డైరెక్టరీ నుండి కొత్తగా రూపొందించబడిన ఎక్జిక్యూటబుల్ మరియు ఆబ్జెక్ట్ ఫైల్‌లను బలవంతంగా శుభ్రం చేయడానికి క్లీన్ టార్గెట్ దాని “rm” ఆదేశాన్ని ఉపయోగిస్తుంది.
CXX = g++CXXFLAGS = - గోడ -ఎస్టీడీ =c++ పదకొండు
EXECUTABLE = హలో
SRCS = $ ( వైల్డ్కార్డ్ * .cpp )
OBJS = $ ( SRCS:.cpp=.o )
అన్నీ: $ ( అమలు చేయదగినది )
$ ( అమలు చేయదగినది ) : $ ( OBJS )
$ ( CXX ) $ ( CXXFLAGS ) -ఓ $ @ $ ( OBJS )
% .ఓ: % .cpp
$ ( CXX ) $ ( CXXFLAGS ) -సి $ < -ఓ $ @
శుభ్రం:
rm -ఎఫ్ $ ( అమలు చేయదగినది ) $ ( OBJS )
“మేక్” సూచనను అమలు చేసిన తర్వాత, లక్ష్యం మరియు ఆబ్జెక్ట్ ఫైల్‌లు రెండూ సృష్టించబడ్డాయి. ఎక్జిక్యూటబుల్ 'హలో' ఫైల్‌ను అమలు చేసిన తర్వాత, వినియోగదారుని జీతం నమోదు చేయమని అడుగుతారు మరియు మేము '67000'ని జోడిస్తాము. చివర్లో, జీతం తిరిగి ప్రదర్శించబడుతుంది.
తయారు 
ఉదాహరణ 2: Foreach ఉపయోగించడం
వైల్డ్‌కార్డ్‌లను ఉపయోగించిన తర్వాత, మేక్‌ఫైల్‌లో ఫోర్చ్ ఫంక్షన్‌ని ఉపయోగించుకోవాల్సిన సమయం ఇది. మిగిలిన మేక్‌ఫైల్ కోడ్ కూడా అలాగే ఉంటుంది. లైన్ 6లో, కేట్, కిమ్, టిమ్ అనే మూడు విలువల జాబితాతో “NAMES” అనే మరొక వేరియబుల్‌ని ప్రారంభిస్తాము. డిఫాల్ట్ “అన్ని” లక్ష్యం ఎక్జిక్యూటబుల్ వేరియబుల్ (టార్గెట్ ఫైల్ పేరు “హలో”) మరియు ఫోర్చ్ స్టేట్‌మెంట్‌పై ఆధారపడి ఉంటుంది. “Addprefix” ఫంక్షన్ “NAMES” జాబితాలోని ప్రతి పేరు ప్రారంభంలో “run_”ని ప్రిఫిక్స్ చేయడం ద్వారా లక్ష్య పేర్లను డైనమిక్‌గా రూపొందించడానికి “NAMES” వేరియబుల్‌ని పునరావృతం చేస్తుంది.
ఎనిమిది లైన్‌లోని నియమం అవుట్‌పుట్ ఎక్జిక్యూటబుల్ టార్గెట్ ఫైల్, అంటే హలో, “OBJS”పై ఆధారపడి ఉంటుందని సూచిస్తుంది. '-o' ఫ్లాగ్ OBJSని ఉపయోగించి లక్ష్య అవుట్‌పుట్ ఫైల్‌ను ఉత్పత్తి చేస్తుంది. పదవ పంక్తిలోని నియమం 'cpp' పొడిగింపుతో సోర్స్ ఫైల్‌లను ఉపయోగించి లక్ష్య ఆబ్జెక్ట్ ఫైల్‌ను రూపొందిస్తుంది. అలా చేయడానికి, సోర్స్ ఫైల్‌ను కంపైల్ చేయడానికి మరియు లక్ష్య ఉత్పత్తికి అవసరమైన సంబంధిత ఆబ్జెక్ట్ ఫైల్‌ను రూపొందించడానికి “-c” ఫ్లాగ్ ఉపయోగించబడుతుంది. పదమూడవ పంక్తిలో, ఉపసర్గగా “run_”తో ప్రారంభమయ్యే విభిన్న పేర్లతో అవుట్‌పుట్‌ను రూపొందించడానికి మేము EXECUTABLE వేరియబుల్‌ని ఉపయోగిస్తాము. చివరికి, క్లీన్ టార్గెట్ మరియు ఫోనీ టార్గెట్‌లు ఆబ్జెక్ట్ మరియు టార్గెట్ ఫైల్‌లను తీసివేస్తాయి మరియు శుభ్రపరుస్తాయి.
CXX = g++CXXFLAGS = - గోడ -ఎస్టీడీ =c++ పదకొండు
# ఎక్జిక్యూటబుల్ టార్గెట్ ఫైల్
EXECUTABLE = హలో
SRCS = $ ( వైల్డ్కార్డ్ * .cpp )
OBJS = $ ( SRCS:.cpp=.o )
# పేర్ల జాబితా
పేర్లు = కేట్ కిమ్ టిమ్
# లక్ష్యాలు
అన్నీ: $ ( అమలు చేయదగినది ) $ ( addprefix run_, $ ( పేర్లు ) )
$ ( అమలు చేయదగినది ) : $ ( OBJS )
$ ( CXX ) $ ( CXXFLAGS ) -ఓ $ @ $ ( OBJS )
% .O: % .cpp
$ ( CXX ) $ ( CXXFLAGS ) -సి $ < -ఓ $ @
# ప్రతి పేరు కోసం లక్ష్యాలను సృష్టించండి
పరుగు_ % : $ ( అమలు చేయదగినది )
. / $ ( అమలు చేయదగినది ) $*
శుభ్రం:
rm -ఎఫ్ $ ( అమలు చేయదగినది ) $ ( OBJS )
# నకిలీ లక్ష్యాలు
.PHONY: అన్నీ శుభ్రంగా ఉన్నాయి
“మేక్” సూచనల ఉపయోగం ఎక్జిక్యూటబుల్ “హలో” లక్ష్యాన్ని ఉత్పత్తి చేస్తుంది మరియు “NAMES” వేరియబుల్‌లో పేర్కొన్న ప్రతి పేరు కోసం ప్రోగ్రామ్‌ను అమలు చేస్తుంది.
తయారు 
మీరు 'run_' ఉపసర్గతో జాబితా నుండి పేరును ఉపయోగించి మీ అవుట్‌పుట్‌ను కూడా సవరించవచ్చు.
రన్_కిమ్ చేయండి 
ముగింపు
ఈ గైడ్ వైల్డ్‌కార్డ్‌ల వినియోగాన్ని మరియు మేక్‌ఫైల్‌లో ఫోరీచ్ కాన్సెప్ట్‌లను వాటి వాక్యనిర్మాణాన్ని విడిగా చర్చిస్తూ చర్చించింది. ఆ తర్వాత, ఒకే ఎక్స్‌టెన్షన్‌లతో ఫైల్‌లను పొందడం మరియు వేరియబుల్ జాబితాలో విలువలను పునరావృతం చేయడంపై అవుట్‌పుట్‌లతో వారి ప్రతి పనిని వివరించడానికి మేము కోడ్ ఉదాహరణలను చర్చించాము.