c makefile tutorial
В този урок за C ++ Makefile ще обсъдим основните аспекти на инструмента Make и makefile, включително неговите предимства и приложения в C ++:
Във всеки проект на C ++ една от важните цели е да се опрости изграждането на проекта, така че да получим всички зависимости и файловете на проекта на едно място и да ги изпълним наведнъж, така че да получим желания изход с една команда.
въпроси за интервю за селен за 7-годишен опит
В същото време, когато някой от файловете на проекта се модифицира, не е нужно да преживяваме проблема с изграждането на целия проект отново, т.е. когато файл или два са модифицирани в проекта, ние възстановяваме само тези променени файлове и след това продължаваме с изпълнението.
=> Прочетете серията Easy C ++ Training.
Това са точно функциите, които се разглеждат от инструмента “make” и “makefiles” в C ++. В този урок ще обсъдим всички основни аспекти на make-файловете, както и техните приложения в C ++.
Какво ще научите:
Make Tool
Make е UNIX инструмент и се използва като инструмент за опростяване на изграждането на изпълним файл от различни модули на проект. Има различни правила, които са посочени като целеви записи в makefile. Инструментът make чете всички тези правила и се държи съответно.
Например, ако правило указва някаква зависимост, тогава инструментът make ще включва тази зависимост за целите на компилирането. Командата make се използва в makefile за изграждане на модули или за почистване на файловете.
Общият синтаксис на make е:
%make target_label #target_label is a specific target in makefile
Например , ако искаме да изпълним rm команди за почистване на файлове, пишем:
% make clean #here clean е target_label, посочен за rm команди
C ++ Makefile
Makefile не е нищо друго освен текстов файл, който се използва или се препраща от командата ‘make’ за изграждане на целите. Makefile също съдържа информация като зависимости на ниво източник за всеки файл, както и зависимости от реда за изграждане.
Сега нека видим общата структура на makefile.
Makefile обикновено започва с декларации на променливи, последвани от набор от целеви записи за изграждане на конкретни цели. Тези цели могат да бъдат .o или други изпълними файлове в C или C ++ и .class файлове в Java.
Може да имаме и набор от целеви записи за изпълнение на набор от команди, посочени от целевия етикет.
Така че общият makefile е както е показано по-долу:
# comment target: dependency1 dependency2 ... dependencyn command # (note: the in the command line is necessary for make to work)
Прост пример за makefile е показан по-долу.
# a build command to build myprogram executable from myprogram.o and mylib.lib all:myprogram.o mylib.o gcc –o myprogram myprogram.o mylib.o clean: $(RM) myprogram
В горния makefile сме посочили два целеви етикета, първият е етикетът „всички“ за изграждане на изпълним файл от myprogram и обектни файлове mylib. Вторият целеви етикет „чист“ премахва всички файлове с името „myprogram“.
Нека да видим друга вариация на makefile.
# the compiler: gcc for C program, define as g++ for C++ CC = gcc # compiler flags: # -g - this flag adds debugging information to the executable file # -Wall - this flag is used to turn on most compiler warnings CFLAGS = -g -Wall # The build target TARGET = myprogram all: $(TARGET) $(TARGET): $(TARGET).c $(CC) $(CFLAGS) -o $(TARGET) $(TARGET).c clean: $(RM) $(TARGET)
Както е показано в горния пример, в този makefile ние използваме променливата ‘CC’, която съдържа стойността на компилатора, която използваме (GCC в този случай). Друга променлива ‘CFLAGS’ съдържа флаговете на компилатора, които ще използваме.
Третата променлива ‘TARGET’ съдържа името на програмата, за която трябва да изградим изпълнимия файл.
Предимството на мярката на този вариант на makefile е, че просто трябва да променим стойностите на променливите, които сме използвали, когато има някаква промяна в компилатора, флаговете на компилатора или името на изпълнимата програма.
Пример за Make And Makefile
Помислете за пример на програма със следните файлове:
- Main.cpp: Основна програма за водача
- Point.h: Заглавен файл за точков клас
- Point.cpp: CPP файл за изпълнение за точков клас
- Square.h: Заглавен файл за квадратен клас
- Square.cpp; CPP файл за внедряване за квадратен клас
С дадените по-горе .cpp и .h файлове ние трябва да компилираме тези файлове поотделно, за да генерираме .o файлове и след това да ги свържем в изпълним с име main.
След това компилираме тези файлове поотделно.
- g ++ -c main.cpp: генерира main.o
- g ++ -c point.cpp: генерира точка.o
- g ++ -c square.cpp: генерира квадрат.o
След това свързваме обектните файлове заедно, за да генерираме изпълнимия main.
g ++ -o main main.o point.o square.o
След това трябва да решим кой от файловете ще трябва да рекомпилираме и регенерираме, когато се актуализират определени части от програмата. За това ще имаме диаграма на зависимостта който показва различни зависимости за всеки от файловете за изпълнение.
По-долу е дадена диаграмата на зависимостите за горните файлове.
Така че в горната таблица на зависимостите можем да видим изпълнимия ‘main’ в основата. Изпълнимият ‘main’ се състои от обектни файлове, а именно. main.o, point.o, square.o, който се генерира чрез компилиране на main.cpp, point.cpp и square.cpp съответно.
Всички реализации на cpp използват заглавни файлове, както е показано в горната диаграма. Както е показано по-горе main.cpp се позовава на point.h и square.h, тъй като е програмата за драйвери и използва класове point и square.
Следващият файл point.cpp препраща към point.h. Третият файл square.cpp се позовава на square.h, както и на point.h, тъй като ще му е необходима и точка, за да нарисува квадрата.
От таблицата на зависимостите по-горе става ясно, че когато се променя всеки .cpp файл или .h файл, посочен от .cpp файл, трябва да регенерираме този .o файл. Например, когато main.cpp се промени, трябва да регенерираме main.o и да свържем обектните файлове отново, за да генерираме основния изпълним файл.
Всички горепосочени обяснения, които сме дали, ще работят безпроблемно, ако в проекта има малко файлове. Когато проектът е огромен и файловете са големи и твърде много, тогава става трудно да се регенерират многократно файловете.
По този начин ние използваме make файлове и използваме за създаване на инструмент за изграждане на проекта и генериране на изпълнимия файл.
Вече видяхме различни части от файл с марки. Имайте предвид, че файлът трябва да бъде наречен „MAKEFILE“ или „makefile“ и трябва да бъде поставен в папката източник.
Сега ще запишем makefile за горния пример.
Ще дефинираме променливи, които да съдържат стойностите на флаговете на компилатора и компилатора, както е показано по-долу.
CC = g++ CFLAGS = -wall -g
След това създаваме първата цел в нашия makefile, т.е. изпълнимия main. Така че ние пишем цел с нейните зависимости.
main: main.o point.o square.o
По този начин командата за генериране на тази цел е
$(CC) $(CFLAGS) –o main main.o point.o square.o
Забележка: Горната команда всъщност се превежда в g ++ -wall –g –o main main.o point.o square.o
Следващата ни цел ще бъде да генерираме обектни файлове, main.o, point.o, square.o
Сега, за да генерира main.o, целта ще бъде записана като:
Main.o: main.cpp point.h square.h
Командата за тази цел е:
$(CC) $(CFLAGS) –c main.cpp
Следващият файл point.o може да бъде генериран с помощта на командата по-долу:
$(CC) $(CFLAGS) –c point.h
В горната команда пропуснахме point.cpp. Това е така, защото make вече знае, че .o файловете се генерират от .cpp файловете, така че е достатъчен само .h (включва файл).
По същия начин square.o може да бъде генериран със следната команда.
$(CC) $(CFLAGS) –c square.h point.h
Целият makefile за този пример ще изглежда както е показано по-долу:
# Makefile for Writing Make Files Example # ***************************************************** # Variables to control Makefile operation CC = g++ CFLAGS = -Wall -g # **************************************************** # Targets needed to bring the executable up to date main: main.o Point.o Square.o $(CC) $(CFLAGS) -o main main.o Point.o Square.o # The main.o target can be written more simply main.o: main.cpp Point.h Square.h $(CC) $(CFLAGS) -c main.cpp Point.o: Point.h Square.o: Square.h Point.h
По този начин виждаме, че имаме пълен makefile, който компилира три C ++ файла и след това генерира изпълним main от обектните файлове.
Предимства на Makefiles
- Когато става въпрос за големи проекти, тогава използването на makefile помага да представим проекта по систематичен и ефективен начин.
- Makefiles правят изходния код по-кратък и лесен за четене и отстраняване на грешки.
- Makefiles автоматично компилира само тези файлове, които са променени. По този начин не е необходимо да регенерираме целия проект, когато някои от частите на проекта са променени.
- Инструментът Make ни позволява да компилираме няколко файла наведнъж, така че всички файлове да могат да бъдат компилирани в една стъпка.
Заключение
Makefiles са благодат за разработването на софтуер. Използвайки C ++ makefile, можем да изградим решения за по-кратко време. Също така, когато част от проекта се модифицира, makefile прекомпилира и регенерира само тази част, без да се налага да регенерира целия проект.
C ++ Makefile ни позволява да представяме проекта систематично и ефективно, като по този начин го прави по-четлив и лесен за отстраняване на грешки.
В този урок на C ++ Makefile видяхме подробно makefile и инструменти за изработка. Също така обсъдихме как да напишем makefile от нулата.
=> Вижте Перфектното ръководство за обучение на C ++ тук.
Препоръчително четене
- 70+ НАЙ-ДОБРИ уроци за C ++, за да научите БЕЗПЛАТНО програмиране на C ++
- Dev C ++ IDE: Инсталация, функции и разработка на C ++
- Пълен преглед на C ++
- Обекти на VBScript файл: CopyFile, DeleteFile, OpenTextFile, четене и запис на текстов файл
- Урок за работа с файлове на Python: Как да създавам, отварям, чета, пиша
- Команди на файловата система Unix Touch, Cat, Cp, Mv, Rm, Mkdir (част Б)
- 12 най-добри IDE на Python и редактори на код през 2021 г.
- Топ 15 най-добри безплатни редактори на кодове за перфектно кодиране