Laten we eerlijk zijn. Het met de hand uittypen van lange gcc -compilatiecommando’s is lastig. Het wordt snel erger als je codebase groeit, meerdere bibliotheken importeert en je voortdurend dingen aan het aanpassen bent. Je krijgt een copy-paste-nachtmerrie die kapot gaat als je een vlag mist.
Voer makefiles in.
Ze bestaan om één reden: om te voorkomen dat u steeds opnieuw dezelfde compilatiereeks handmatig typt. In plaats van de exacte vlaggen en volgorde van objectbestanden te onthouden, schrijft u een recept. Vervolgens typ je gewoon ‘make’.
Hoe een Makefile eigenlijk werkt
Je begint met het maken van een bestand dat letterlijk makefile heet. Geen verlenging. Alleen de naam. Binnenin definieer je afhankelijkheden.
Hier is een basisstructuur voor een klein C-project:
Let op de inkeping. Dit is waar beginners struikelen. Die spatie vóór gcc? Het moet een tab-teken zijn. Geen acht spaties. Een tabblad. Als je spaties gebruikt, genereert make een cryptische fout en vraag je je tien minuten af waarom jouw syntaxis er voor het menselijk oog goed uitziet, maar niet voor de machine. Elke opdrachtregel onder een afhankelijkheid moet beginnen met een tabblad. De afhankelijkheidsdefinities zelf moeten links liggen. Geen uitzonderingen.
De logica van afhankelijkheden
Een makefile heeft twee soorten lijnen. De eerste zijn afhankelijkheidslijnen. Deze zien eruit als doel: vereisten.
main.o: main.c util.h
Dit vertaalt zich naar: “Ik heb main.o nodig. Om het te krijgen, heb ik main.c en util.h nodig.’
Het tweede type is de uitvoerbare regel. Het bevindt zich onder de afhankelijkheid en begint met een tabblad. Het is het commando dat wordt uitgevoerd als make besluit dat het opnieuw moet worden opgebouwd.
Het systeem werkt volgens een eenvoudig principe: als een bestand aan de rechterkant van de dubbele punt nieuwer is dan het bestand aan de linkerkant, voert u de onderstaande opdrachten uit. util.h wijzigen? make ziet het, weet dat main.o en util.o ervan afhankelijk zijn, en herbouwt ze. Het automatiseert de logica.
De doelregel
Er is één gouden regel voor de bovenkant van je makefile. Het eerste vermelde doel is het doel dat make standaard probeert te bouwen.
In het bovenstaande voorbeeld is ‘main’ de eerste regel. Dus als je make uitvoert zonder argumenten, wordt het uiteindelijke uitvoerbare bestand gebouwd.
main: main.o util.o
gcc -o main main.o util.o
Als u main.o wijzigt, wordt het opnieuw opbouwen van main geactiveerd. Als u main.c wijzigt, wordt main.o geactiveerd, wat vervolgens main activeert. Het is een kettingreactie. Je hoeft het niet te beheren. U bewerkt gewoon uw broncode en voert make uit.
Wat als ik geen Unix gebruik?
Als u Windows gebruikt of een IDE zoals Visual Studio of Xcode gebruikt, ziet u mogelijk geen ‘makefile’ in de traditionele zin. Geen paniek. Uw compiler heeft waarschijnlijk een gelijkwaardige functionaliteit.
Geïntegreerde ontwikkelomgevingen hebben vaak build-systemen onder de motorkap. Zoek naar ‘Buildconfiguraties’ of ‘Projecteigenschappen’. Ze doen hetzelfde: afhankelijkheden volgen en alleen opnieuw compileren wat er is veranderd. Maar als u zich aan de opdrachtregel houdt, is make de standaard.
Het grotere plaatje
Het gebruik van make is dat niet
