సాఫ్ట్‌వేర్ ప్రాజెక్ట్‌లను రూపొందించడానికి ఆదేశాలను నిల్వ చేయడానికి “మేక్‌ఫైల్” అని పిలువబడే టెక్స్ట్ ఫైల్ ఉపయోగించబడుతుంది. ఇది లక్ష్య ఫైల్‌ని ఉపయోగించి ప్రాజెక్ట్ యొక్క అసలైన కోడ్‌ను స్వయంచాలకంగా లింక్ చేస్తుంది, సెట్ చేస్తుంది మరియు కంపైల్ చేస్తుంది. సోర్స్ కోడ్ ఫైల్ నుండి ఆబ్జెక్ట్ మరియు టార్గెట్ ఫైల్‌లను సృష్టించడానికి మేక్‌ఫైల్ ఉపయోగించబడుతుంది. లక్ష్య ఫైల్ అమలు చేయబడిన తర్వాత, సోర్స్ కోడ్ ఫైల్‌లోని కోడ్ అమలు చేయబడుతుంది మరియు మీ ప్రాజెక్ట్ ఏ సమయంలోనైనా అమలు చేయబడుతుంది. ఈ గైడ్‌లో, వేరియబుల్స్ మరియు ఆర్గ్యుమెంట్‌లను ఉపయోగించి మేక్‌ఫైల్‌ను ఎలా తయారు చేయాలనే దాని గురించి మేము మీకు సమగ్ర వివరాలను అందిస్తాము.
ప్రాథమిక మేక్‌ఫైల్ మూడు భాగాలను కలిగి ఉంటుంది:
- ప్రాజెక్ట్-సంబంధిత డేటాను నిల్వ చేయడానికి వేరియబుల్స్ ఎంటిటీలు లేబుల్ చేయబడ్డాయి.
- మేక్‌ఫైల్‌లోని డిపెండెన్సీలను ఉపయోగించి ఉద్దేశించిన ఫైల్‌ను ఎలా సృష్టించాలో నియమాలు పేర్కొంటాయి.
- మేక్‌ఫైల్ రూపొందించబడిన పత్రాలను లక్ష్యాలుగా సూచిస్తారు.
మేక్‌ఫైల్ వేరియబుల్స్
మేము ఇప్పటికే వివరించినట్లుగా, డేటాను నిల్వ చేయడానికి ఉపయోగించబడే లేబుల్ చేయబడిన వస్తువును మేక్‌ఫైల్ వేరియబుల్‌గా సూచిస్తారు. వేరియబుల్ విలువ ఒకే అక్షరం, సంఖ్యా విలువ లేదా విలువల సమాహారం కావచ్చు. మూలం మరియు లక్ష్య పత్రాల శీర్షికలు, అలాగే లక్ష్యాలను రూపొందించడానికి ఉపయోగించాల్సిన సూచనలు, వేరియబుల్స్‌లో నిల్వ చేయబడిన నిర్మాణ విధానానికి సంబంధించిన మొత్తం డేటా.
Makefile వేరియబుల్స్ సృష్టించండి
మేక్‌ఫైల్‌లో సాధారణ వేరియబుల్‌ని నిర్వచించడానికి, మనం దానిని సాధారణ శీర్షికతో ప్రారంభించాలి, దాని తర్వాత “=” గుర్తు మరియు దానిలో నిల్వ చేయబడే విలువ:
name_of_variable = value_of_variable
మరోవైపు, ప్రాజెక్ట్ యొక్క శీఘ్ర మరియు ఉత్తమ పనితీరు కోసం “=”కి బదులుగా “:=” ప్రయత్నించడం ప్రాధాన్యతనిస్తుంది మరియు సిఫార్సు చేయబడింది.
name_of_variable := value_of_variable
ఉదాహరణకు, మేము C ప్రాజెక్ట్ కోసం మేక్‌ఫైల్‌ని సృష్టించి, “CC” వేరియబుల్‌ని ప్రకటిస్తాము. ఈ వేరియబుల్ C కోసం అమలు చేయగల కంపైలర్‌ను నిల్వ చేస్తుంది, అంటే “gcc”, విలువగా. నాల్గవ పంక్తిలో, కంపైలేషన్ ప్రక్రియ జరుగుతున్నప్పుడు హెచ్చరికలను అందించడానికి ఉపయోగించే “CFLAGS” వేరియబుల్‌ను మేము సృష్టిస్తాము. ఇది మీరు అమలు చేస్తున్న ప్రాజెక్ట్ యొక్క ఆప్టిమైజేషన్‌ను మెరుగుపరచడం మరియు ఏవైనా సమస్యలను నివారించడం.
అలాగే, ఈ కోడ్ స్నిప్పెట్‌లోని “TARGET” వేరియబుల్ మేక్‌ఫైల్ అమలు చేసిన తర్వాత రూపొందించబడిన కొత్త టార్గెట్ ఫైల్‌ను సెట్ చేయడానికి ఉపయోగించబడుతుంది. మేక్ ఫైల్‌ను సృష్టిస్తున్నప్పుడు, టార్గెట్ ఫైల్‌ను సెట్ చేసిన తర్వాత సోర్స్ మరియు ఆబ్జెక్ట్ ఫైల్‌లను సెట్ చేయడం అవసరం. మూలం మరియు ఆబ్జెక్ట్ ఫైల్‌లను వేరియబుల్స్ ఉపయోగించి కూడా నిర్వచించవచ్చు. మీరు మీ ఎంపిక ప్రకారం ఈ వేరియబుల్స్ పేరు పెట్టవచ్చు.
ఉదాహరణకు, SRCS వేరియబుల్ సోర్స్ ఫైల్‌ను సెట్ చేస్తుంది, అయితే OBJS వేరియబుల్ SRCS వేరియబుల్ ఉపయోగించి కొత్త ఆబ్జెక్ట్ ఫైల్‌ను సెట్ చేస్తుంది.
CC = gccCFLAGS = - గోడ
TARGET = కొత్తది
SRCS = main.c
OBJS = $ ( SRCS:.c=.o )
Makefile వేరియబుల్స్ ఉపయోగించండి
మేక్‌ఫైల్ వేరియబుల్స్‌ను డిక్లేర్ చేసిన తర్వాత లేదా నిర్వచించిన తర్వాత, వాటిని మేక్‌ఫైల్‌లో ఉపయోగించగలిగేలా చేయడం చాలా అవసరం. మేక్‌ఫైల్ వేరియబుల్‌ని ఉపయోగించడానికి, మీరు “$” గుర్తును ఉపయోగించాలి, దాని తర్వాత “()” లేదా “{}” బ్రాకెట్‌లు ఉంటాయి. ఉదాహరణకు, టార్గెట్ ఎక్జిక్యూటబుల్ ఫైల్‌ను రూపొందించడానికి మేము “$()”ని ఉపయోగిస్తాము. ఈ దశను చేసిన తర్వాత, లక్ష్య ఫైల్ ప్రతిస్పందించగలదు.
అన్నీ: $ ( TARGET )
Makefile వాదనలు
మేక్‌ఫైల్‌ని పిలిచినప్పుడల్లా, దానికి 'ఆర్గ్యుమెంట్' అని పిలువబడే పారామీటర్‌గా ఒక విలువ సరఫరా చేయబడుతుంది. మ్యూటబుల్ యొక్క అసలు విలువను భర్తీ చేయడానికి లేదా రన్‌టైమ్‌లో మేక్‌ఫైల్‌కు మరిన్ని వివరాలను జోడించడానికి ఆర్గ్యుమెంట్‌లు ఉపయోగించబడతాయి. మేక్‌ఫైల్‌లోని వేరియబుల్‌కి కమాండ్-లైన్ ఆర్గ్యుమెంట్‌లను పాస్ చేయడానికి, మీరు “మేక్” కీవర్డ్‌ని ఉపయోగించాలి, దాని తర్వాత వేరియబుల్ పేరు మరియు దానికి పంపబడే ఆర్గ్యుమెంట్ విలువ ఉంటుంది:
తయారు name_of_variable = value_of_variable
ఈ పారామీటర్‌లను మేక్‌ఫైల్‌లో సాధారణ వేరియబుల్స్‌గా యాక్సెస్ చేయవచ్చు, అంటే “కొత్త” అనేది “టార్గెట్” వేరియబుల్ యొక్క ఆర్గ్యుమెంట్ విలువ.
TARGET = కొత్తది
ఉదాహరణ: వేరియబుల్స్ మరియు ఆర్గ్యుమెంట్స్ చేయండి
మేక్‌ఫైల్‌లో వేరియబుల్స్ మరియు ఆర్గ్యుమెంట్‌ల వినియోగాన్ని ప్రదర్శించడానికి, మేము C++లో ఒక సాధారణ ఉదాహరణను ఉపయోగిస్తాము. మేము నోట్‌ప్యాడ్++లో కొత్త C++ ఫైల్‌ని సృష్టిస్తాము మరియు నమూనా ప్రోగ్రామ్‌లో ఇన్‌పుట్ మరియు అవుట్‌పుట్‌ను ఉపయోగించడానికి “iostream” హెడర్‌ను జోడిస్తాము.
ప్రధాన() ఫంక్షన్ క్యారెక్టర్ టైప్ వేరియబుల్ “v” డిక్లరేషన్‌తో ప్రారంభమవుతుంది. 'కౌట్' అనే ప్రామాణిక అవుట్‌పుట్ స్ట్రీమ్ వినియోగదారుని ఇన్‌పుట్ కోసం ప్రదర్శించడానికి మరియు అడగడానికి ఉపయోగించబడుతుంది. దీనికి విరుద్ధంగా, “cin” ప్రామాణిక ఇన్‌పుట్ స్ట్రీమ్ రన్‌టైమ్‌లో వినియోగదారు నుండి ఇన్‌పుట్ విలువను పొందుతుంది మరియు దానిని “v” వేరియబుల్‌కు సేవ్ చేస్తుంది. రన్-టైమ్‌లో వినియోగదారు జోడించిన విలువను ప్రదర్శించడానికి ప్రామాణిక “కౌట్” మళ్లీ ఉపయోగించబడుతుంది. 'రిటర్న్ 0' స్టేట్‌మెంట్ ప్రోగ్రామ్ ఎగ్జిక్యూషన్‌ను విజయవంతంగా ముగించింది.
#పూర్ణాంక ప్రధాన ( ) {
చార్ v;
std::cout << 'విలువను నమోదు చేయండి:' ;
std::cin >> లో;
std::cout << లో << std::endl;
తిరిగి 0 ;
}
మేక్‌ఫైల్ ప్రామాణిక మార్గాన్ని ఉపయోగించి రూపొందించబడుతుంది. మొట్టమొదటి వేరియబుల్, “CXX”, C++ ఫైల్‌ను అమలు చేయడానికి కంపైలర్‌ను ఉపయోగించాలని ప్రకటించింది, అనగా “g++”. ఏదైనా సమస్యలను నివారించడానికి కంపైలర్ కోసం ఫ్లాగ్‌లను సెట్ చేయడానికి తదుపరి వేరియబుల్ ఉపయోగించబడుతుంది.
ఇప్పుడు, టార్గెట్ ఫైల్ “TARGET” వేరియబుల్‌ని ఉపయోగించి “కొత్తది”కి సెట్ చేయబడింది. ఇది ఎక్జిక్యూటబుల్ ఫైల్. దీని తరువాత, మేక్‌ఫైల్ దాని మూలం మరియు ఆబ్జెక్ట్ ఫైల్‌ను SRCS మరియు OBJS వేరియబుల్స్ ద్వారా నిర్వచిస్తుంది. డిక్లేర్డ్ వేరియబుల్స్‌ని ఉపయోగించుకోవడానికి, టార్గెట్ ఎక్జిక్యూటబుల్, ఆబ్జెక్ట్ ఫైల్‌ను రూపొందించడానికి మరియు ఆబ్జెక్ట్ మరియు టార్గెట్ ఫైల్‌ను క్లీన్ చేయడానికి మేము “$” గుర్తును అనుసరించి “()” బ్రాకర్‌లను ఉపయోగిస్తాము.
CXX = g++CXXFLAGS = -ఎస్టీడీ =c++ పదకొండు - గోడ
TARGET = కొత్తది
SRCS = main.cpp
OBJS = $ ( SRCS:.cpp=.o )
అన్నీ: $ ( TARGET )
$ ( TARGET ) : $ ( OBJS )
$ ( CXX ) $ ( CXXFLAGS ) -ఓ $ ( TARGET ) $ ( OBJS )
% .O: % .cpp
$ ( CXX ) $ ( CXXFLAGS ) -సి $ < -ఓ $ @
శుభ్రం:
rm -ఎఫ్ $ ( TARGET ) $ ( OBJS )
C++ మరియు దాని మేక్‌ఫైల్‌ను సేవ్ చేసిన తర్వాత, మీ సిస్టమ్ యొక్క CMDని ప్రారంభించండి, వర్కింగ్ డైరెక్టరీలోకి నావిగేట్ చేయండి మరియు ఈ క్రింది విధంగా తయారీ సూచనను అమలు చేయండి. ఇది సోర్స్ కోడ్ ఫైల్ కోసం “main.o” ఆబ్జెక్ట్ ఫైల్ మరియు “New.exe” టార్గెట్ ఫైల్‌ను ఉత్పత్తి చేస్తుంది. ప్రస్తుతానికి సూచనలను చేయడానికి మేము ఎటువంటి వాదనను ఆమోదించలేదు.
తయారు
లక్ష్య ఫైల్‌ను అమలు చేయడం వలన వినియోగదారుని ఇన్‌పుట్ కోసం అడుగుతుంది. మేము మొదటి అమలులో 'h' అక్షరాన్ని మరియు రెండవ అమలులో 'haha'ని జోడిస్తాము. “v” వేరియబుల్ “అక్షర” విలువలను మాత్రమే అంగీకరిస్తుంది, “haha” స్ట్రింగ్ నుండి “h” అక్షరం నిల్వ చేయబడుతుంది మరియు ప్రదర్శించబడుతుంది.
New.exe
మేక్‌ఫైల్ వేరియబుల్స్‌కు పంపబడే కమాండ్-లైన్ ఆర్గ్యుమెంట్‌లను ఉపయోగించి మేక్ ఇన్‌స్ట్రక్షన్‌ని రన్ చేద్దాం. కాబట్టి, మేము 'TARGET' వేరియబుల్ విలువను మారుస్తాము మరియు దానికి 'పరీక్ష' పాస్ చేస్తాము. ఆ తర్వాత, 'Test.exe' ఫైల్ ఉత్పత్తి చేయబడుతుంది మరియు సరిగ్గా 'New.exe' ఫైల్ వలె పనిచేస్తుంది.
తయారు TARGET = పరీక్షTest.exe
ముగింపు
ఈ సమగ్ర గైడ్‌లో, మేము మేక్‌ఫైల్ యొక్క కంటెంట్‌లను ఒక్కొక్కటిగా పరిశీలించాము. మేక్‌ఫైల్‌లో వేరియబుల్స్‌ను ఎలా డిక్లేర్ చేయాలి, వాటిని ఎలా ఉపయోగపడేలా చేయాలి మరియు ఆర్గ్యుమెంట్‌ల సహాయంతో రన్‌టైమ్‌లో వాటి విలువను ఎలా మార్చాలి అనే విషయాలను మేము వివరించాము. మా వివరణకు మద్దతుగా, మేము C++లో ఒక సాధారణ ఉదాహరణను చర్చించాము.