மென்பொருள் திட்டங்களை உருவாக்குவதற்கான கட்டளைகளை சேமிக்க 'makefile' எனப்படும் உரை கோப்பு பயன்படுத்தப்படுகிறது. இது இலக்குக் கோப்பைப் பயன்படுத்தி திட்டத்தின் அசல் குறியீட்டை தானாகவே இணைக்கிறது, அமைக்கிறது மற்றும் தொகுக்கிறது. மூலக் குறியீடு கோப்பிலிருந்து ஒரு பொருளை உருவாக்குவதற்கும் இலக்கு கோப்புகளை உருவாக்குவதற்கும் ஒரு மேக்ஃபைல் பயன்படுத்தப்படுகிறது. இலக்கு கோப்பின் செயல்பாட்டின் போது, மூல குறியீடு கோப்பில் உள்ள குறியீடு செயல்படுத்தப்படும், மேலும் உங்கள் திட்டம் எந்த நேரத்திலும் இயங்கும். இந்த வழிகாட்டியில், மாறிகள் மற்றும் வாதங்களைப் பயன்படுத்தி மேக்ஃபைலை எவ்வாறு உருவாக்குவது என்பது பற்றிய விரிவான விவரங்களை நாங்கள் உங்களுக்கு வழங்குவோம்.
ஒரு அடிப்படை மேக்ஃபைல் மூன்று பகுதிகளைக் கொண்டுள்ளது:
- மாறிகள் திட்டம் தொடர்பான தரவைச் சேமிக்கும் நிறுவனங்களாக பெயரிடப்பட்டுள்ளன.
- மேக்ஃபைலில் உள்ள சார்புகளைப் பயன்படுத்தி உத்தேசிக்கப்பட்ட கோப்பை எவ்வாறு உருவாக்குவது என்பதை விதிகள் குறிப்பிடுகின்றன.
- மேக்ஃபைல் உருவாக்க வடிவமைக்கப்பட்ட ஆவணங்கள் இலக்குகள் என குறிப்பிடப்படுகின்றன.
மேக்ஃபைல் மாறிகள்
நாங்கள் ஏற்கனவே விவரித்தபடி, தரவைச் சேமிக்கப் பயன்படுத்தப்படும் லேபிளிடப்பட்ட பொருள் ஒரு மேக்ஃபைல் மாறி என குறிப்பிடப்படுகிறது. ஒரு மாறியின் மதிப்பு ஒற்றை எழுத்து, எண் மதிப்பு அல்லது மதிப்புகளின் தொகுப்பாக இருக்கலாம். மூல மற்றும் இலக்கு ஆவணங்களின் தலைப்புகள், அத்துடன் இலக்குகளை உருவாக்கப் பயன்படுத்த வேண்டிய வழிமுறைகள் ஆகியவை மாறிகளில் சேமிக்கப்படும் உருவாக்க செயல்முறை தொடர்பான தரவுகளாகும்.
மேக்ஃபைல் மாறிகளை உருவாக்கவும்
மேக்ஃபைலில் ஒரு எளிய மாறியை வரையறுக்க, அதை ஒரு எளிய தலைப்புடன் தொடங்க வேண்டும், அதைத் தொடர்ந்து “=” அடையாளம் மற்றும் அதில் சேமிக்கப்படும் மதிப்பு:
name_of_variable = value_of_variable
மறுபுறம், ஒரு திட்டத்தின் விரைவான மற்றும் சிறந்த செயல்திறனுக்காக, '=' க்குப் பதிலாக ':=' முயற்சி செய்வது விரும்பப்படுகிறது மற்றும் பரிந்துரைக்கப்படுகிறது.
name_of_variable := value_of_variable
உதாரணமாக, சி திட்டத்திற்கான மேக்ஃபைலை உருவாக்கி, 'சிசி' மாறியை அறிவிக்கிறோம். இந்த மாறியானது C க்கு இயங்கக்கூடிய கம்பைலரை, அதாவது 'gcc' மதிப்பாக சேமிக்கிறது. நான்காவது வரியில், தொகுத்தல் செயல்முறை நடக்கும் போது எச்சரிக்கைகளை வழங்கப் பயன்படும் 'CFLAGS' மாறியை உருவாக்குகிறோம். இது நீங்கள் இயங்கும் ஒரு திட்டப்பணியின் மேம்படுத்தலை மேம்படுத்துவதற்கும், சிக்கல்களைத் தவிர்ப்பதற்கும் ஆகும்.
அது போலவே, இந்த குறியீடு துணுக்கில் உள்ள “TARGET” மாறியானது, மேக்ஃபைலைச் செயல்படுத்திய பிறகு உருவாக்கப்படும் புதிய இலக்கு கோப்பை அமைக்கப் பயன்படுத்தப்படுகிறது. மேக் கோப்பை உருவாக்கும் போது, இலக்கு கோப்பை அமைத்த பிறகு, மூல மற்றும் பொருள் கோப்புகளை அமைக்க வேண்டும். மூல மற்றும் பொருள் கோப்புகளை மாறிகளைப் பயன்படுத்தி வரையறுக்கலாம். உங்கள் விருப்பப்படி இந்த மாறிகளுக்கு நீங்கள் பெயரிடலாம்.
எடுத்துக்காட்டாக, SRCS மாறி ஒரு மூல கோப்பை அமைக்கிறது, OBJS மாறி SRCS மாறியைப் பயன்படுத்தி ஒரு புதிய பொருள் கோப்பை அமைக்கிறது.
CC = gccCFLAGS = - சுவர்
TARGET = புதியது
SRCS = main.c
OBJS = $ ( SRCS:.c=.o )
Makefile மாறிகளைப் பயன்படுத்தவும்
மேக்ஃபைல் மாறிகளை அறிவித்து அல்லது வரையறுத்த பிறகு, அவற்றை மேக்ஃபைலில் பயன்படுத்தக்கூடியதாக மாற்றுவது மிகவும் அவசியம். மேக்ஃபைல் மாறியைப் பயன்படுத்த, நீங்கள் '$' குறியைத் தொடர்ந்து '()' அல்லது '{}' அடைப்புக்குறிகளைப் பயன்படுத்த வேண்டும். உதாரணமாக, இலக்கு இயங்கக்கூடிய கோப்பை உருவாக்க “$()” ஐப் பயன்படுத்துகிறோம். இந்த படி செய்த பிறகு, இலக்கு கோப்பு பதிலளிக்க முடியும்.
அனைத்தும்: $ ( இலக்கு )
மேக்ஃபைல் வாதங்கள்
மேக்ஃபைல் அழைக்கப்படும் போதெல்லாம், அதற்கு ஒரு அளவுருவாக ஒரு மதிப்பு வழங்கப்படுகிறது, அது 'வாதம்' என்று அறியப்படுகிறது. மாற்றக்கூடிய அசல் மதிப்பை மேலெழுத அல்லது இயக்க நேரத்தில் மேக்ஃபைலில் கூடுதல் விவரங்களைச் சேர்க்க வாதங்கள் பயன்படுத்தப்படுகின்றன. ஒரு மேக்ஃபைலில் உள்ள மாறிக்கு கட்டளை வரி வாதங்களை அனுப்ப, நீங்கள் 'make' முக்கிய சொல்லைப் பயன்படுத்த வேண்டும், அதைத் தொடர்ந்து ஒரு மாறி பெயர் மற்றும் அதற்கு அனுப்பப்படும் மதிப்பு மதிப்பு:
செய்ய name_of_variable = value_of_variable
இந்த அளவுருக்கள் மேக்ஃபைலில் சாதாரண மாறிகளாக அணுகப்படலாம், அதாவது “புதிய” என்பது “TARGET” மாறியின் வாத மதிப்பு.
TARGET = புதியது
எடுத்துக்காட்டு: மாறிகள் மற்றும் வாதங்களை உருவாக்கவும்
மேக்ஃபைலில் மாறிகள் மற்றும் வாதங்களின் பயன்பாட்டை நிரூபிக்க, C++ இல் ஒரு எளிய உதாரணத்தைப் பயன்படுத்துகிறோம். Notepad++ இல் புதிய C++ கோப்பை உருவாக்கி, மாதிரி நிரலில் உள்ளீடு மற்றும் வெளியீட்டைப் பயன்படுத்த “iostream” தலைப்பைச் சேர்க்கிறோம்.
முக்கிய() செயல்பாடு ஒரு எழுத்து வகை மாறி “v” இன் அறிவிப்புடன் தொடங்குகிறது. 'கவுட்' என்ற நிலையான வெளியீட்டு ஸ்ட்ரீம் பயனரை உள்ளீட்டைக் காண்பிக்கவும் கேட்கவும் பயன்படுத்தப்படுகிறது. இதற்கு நேர்மாறாக, 'சின்' நிலையான உள்ளீட்டு ஸ்ட்ரீம் இயக்க நேரத்தில் ஒரு பயனரிடமிருந்து உள்ளீட்டு மதிப்பைப் பெற்று அதை 'v' மாறியில் சேமிக்கிறது. ரன்-டைமில் ஒரு பயனரால் சேர்க்கப்படும் மதிப்பைக் காட்ட நிலையான 'கவுட்' மீண்டும் பயன்படுத்தப்படுகிறது. 'திரும்ப 0' அறிக்கை நிரல் செயல்படுத்தலை வெற்றிகரமாக முடிக்கிறது.
#முழு எண்ணாக ( ) {
சார் வி;
std::cout << 'மதிப்பை உள்ளிடவும்:' ;
வகுப்பு::சின் >> உள்ளே;
std::cout << உள்ளே << std::endl;
திரும்ப 0 ;
}
ஒரு மேக்ஃபைல் ஒரு நிலையான வழியைப் பயன்படுத்தி உருவாக்கப்படுகிறது. முதல் மாறி, “CXX”, C++ கோப்பை இயக்க கம்பைலர் பயன்படுத்தப்பட வேண்டும் என்று அறிவிக்கிறது, அதாவது “g++”. எந்தவொரு சிக்கலையும் தவிர்க்க கம்பைலருக்கான கொடிகளை அமைக்க அடுத்த மாறி பயன்படுத்தப்படுகிறது.
இப்போது, இலக்கு கோப்பு 'TARGET' மாறியை பயன்படுத்தி 'புதியதாக' அமைக்கப்பட்டுள்ளது. இது இயங்கக்கூடிய கோப்பு. இதற்குப் பிறகு, மேக்ஃபைல் அதன் மூல மற்றும் பொருள் கோப்பை SRCS மற்றும் OBJS மாறிகள் வழியாக வரையறுக்கிறது. அறிவிக்கப்பட்ட மாறிகளைப் பயன்படுத்த, இலக்கு இயங்கக்கூடிய, ஆப்ஜெக்ட் கோப்பை உருவாக்க மற்றும் பொருள் மற்றும் இலக்கு கோப்பைச் சுத்தம் செய்ய, '()' அடைப்புக்குறிகளைத் தொடர்ந்து '$' அடையாளத்தைப் பயன்படுத்துகிறோம்.
CXX = g++CXXFLAGS = -படிப்பு =c++ பதினொரு - சுவர்
TARGET = புதியது
SRCS = main.cpp
OBJS = $ ( SRCS:.cpp=.o )
அனைத்தும்: $ ( இலக்கு )
$ ( இலக்கு ) : $ ( OBJS )
$ ( CXX ) $ ( CXXFLAGS ) -ஓ $ ( இலக்கு ) $ ( OBJS )
% .O: % .cpp
$ ( CXX ) $ ( CXXFLAGS ) -சி $ < -ஓ $ @
சுத்தமான:
rm -எஃப் $ ( இலக்கு ) $ ( OBJS )
C++ மற்றும் அதன் மேக்ஃபைலைச் சேமித்த பிறகு, உங்கள் கணினியின் CMD ஐத் துவக்கி, வேலை செய்யும் கோப்பகத்திற்குச் சென்று, பின்வரும் வழிமுறைகளைப் பின்பற்றவும். இது மூல குறியீடு கோப்பிற்கான 'main.o' ஆப்ஜெக்ட் கோப்பையும் 'New.exe' இலக்கு கோப்பையும் உருவாக்குகிறது. இப்போதைக்கு வழிமுறைகளை உருவாக்க நாங்கள் எந்த வாதத்தையும் நிறைவேற்றவில்லை.
செய்ய
இலக்கு கோப்பை இயக்குவது பயனரிடம் உள்ளீட்டைக் கேட்கும். முதல் செயல்பாட்டில் “h” எழுத்தையும் இரண்டாவது செயல்பாட்டில் “haha” ஐயும் சேர்க்கிறோம். 'v' மாறியானது 'எழுத்து' மதிப்புகளை மட்டுமே ஏற்கும் போது, 'haha' சரத்திலிருந்து 'h' எழுத்து சேமிக்கப்பட்டு காட்டப்படும்.
New.exe
மேக்ஃபைல் மாறிகளுக்கு அனுப்பப்படும் கட்டளை வரி வாதங்களைப் பயன்படுத்தி தயாரிப்பை இயக்குவோம். எனவே, 'TARGET' மாறி மதிப்பை மாற்றி, அதற்கு 'சோதனை' அனுப்புகிறோம். அதன் பிறகு, 'Test.exe' கோப்பு உருவாக்கப்பட்டு 'New.exe' கோப்பைப் போலவே செயல்படுகிறது.
செய்ய இலக்கு =சோதனைTest.exe
முடிவுரை
இந்த விரிவான வழிகாட்டியில், மேக்ஃபைலின் உள்ளடக்கங்களை ஒவ்வொன்றாகப் பார்த்தோம். மேக்ஃபைலில் மாறிகளை எவ்வாறு அறிவிப்பது, அவற்றை எவ்வாறு பயன்படுத்தக்கூடியதாக மாற்றுவது மற்றும் வாதங்களின் உதவியுடன் இயக்க நேரத்தில் அவற்றின் மதிப்பை எவ்வாறு மாற்றுவது என்பதை விரிவாகக் கூறினோம். எங்கள் விளக்கத்தை ஆதரித்து, C++ இல் ஒரு எளிய உதாரணத்தைப் பற்றி விவாதித்தோம்.