In einer Textdatei namens „Makefile“ werden die Befehle zum Erstellen von Softwareprojekten gespeichert. Der Originalcode des Projekts wird automatisch mit einer Zieldatei verknüpft, eingerichtet und kompiliert. Ein Makefile wird verwendet, um aus einer Quellcodedatei ein Objekt und Zieldateien zu erstellen. Bei der Ausführung einer Zieldatei wird der Code in der Quellcodedatei ausgeführt und Ihr Projekt wird in kürzester Zeit ausgeführt. In diesem Leitfaden geben wir Ihnen ausführliche Informationen zum Erstellen eines Makefiles mithilfe von Variablen und Argumenten.
Ein grundlegendes Makefile besteht aus drei Teilen:
- Bei den Variablen handelt es sich um beschriftete Entitäten zur Speicherung der projektbezogenen Daten.
- Die Regeln geben an, wie eine gewünschte Datei mithilfe der Abhängigkeiten im Makefile erstellt wird.
- Die Dokumente, die das Makefile generieren soll, werden als Ziele bezeichnet.
Makefile-Variablen
Wie bereits beschrieben, wird ein beschriftetes Objekt, das zum Speichern der Daten verwendet werden kann, als Makefile-Variable bezeichnet. Der Wert einer Variablen kann ein einzelnes Zeichen, ein numerischer Wert oder eine Sammlung von Werten sein. Die Titel der Quell- und Zieldokumente sowie die Anweisungen zur Erstellung der Ziele sind allesamt Daten zum Build-Vorgang, die in Variablen gespeichert sind.
Erstellen Sie die Makefile-Variablen
Um eine einfache Variable im Makefile zu definieren, sollten wir sie mit einem einfachen Titel beginnen, gefolgt vom Zeichen „=“ und dem Wert, der darin gespeichert wird:
name_of_variable = value_of_variable
Andererseits wird es bevorzugt und empfohlen, „:=“ anstelle von „=“ auszuprobieren, um eine schnelle und optimale Leistung eines Projekts zu erzielen.
name_of_variable := value_of_variable
Beispielsweise erstellen wir ein Makefile für das C-Projekt und deklarieren eine „CC“-Variable. Diese Variable speichert den für C ausführbaren Compiler, also „gcc“, als Wert. In der vierten Zeile erstellen wir die Variable „CFLAGS“, die verwendet wird, um während des Kompilierungsprozesses Warnungen auszugeben. Dies dient dazu, die Optimierung eines von Ihnen ausgeführten Projekts zu verbessern und etwaige Probleme zu vermeiden.
Genauso wird die Variable „TARGET“ in diesem Codeausschnitt verwendet, um die neue Zieldatei festzulegen, die nach der Ausführung eines Makefiles generiert wird. Beim Erstellen einer Make-Datei ist es notwendig, die Quell- und Objektdateien festzulegen, nachdem eine Zieldatei festgelegt wurde. Über die Variablen können auch die Quell- und Objektdateien definiert werden. Sie können diese Variablen nach Ihren Wünschen benennen.
Beispielsweise legt die SRCS-Variable eine Quelldatei fest, während die OBJS-Variable eine neue Objektdatei mithilfe der SRCS-Variablen festlegt.
CC = gccCFLAGS = -Wand
ZIEL = Neu
SRCS = main.c
OBJS = $ ( SRCS:.c=.o )
Verwenden Sie die Makefile-Variablen
Nach der Deklaration oder Definition der Makefile-Variablen ist es unbedingt erforderlich, sie im Makefile verwendbar zu machen. Um eine Makefile-Variable zu verwenden, müssen Sie das Zeichen „$“ gefolgt von den Klammern „()“ oder „{}“ verwenden. Beispielsweise verwenden wir „$()“, um die ausführbare Zieldatei zu erstellen. Nach diesem Schritt kann die Zieldatei antworten.
alle: $ ( ZIEL )
Makefile-Argumente
Bei jedem Aufruf des Makefiles wird ihm ein Wert als Parameter übergeben, der als „Argument“ bezeichnet wird. Die Argumente werden verwendet, um den ursprünglichen Wert einer veränderlichen Variable zu überschreiben oder um zur Laufzeit weitere Details zum Makefile hinzuzufügen. Um die Befehlszeilenargumente an eine Variable in einem Makefile zu übergeben, sollten Sie das Schlüsselwort „make“ verwenden, gefolgt von einem Variablennamen und einem Argumentwert, der an die Variable übergeben wird:
machen name_of_variable = value_of_variable
Auf diese Parameter kann als gewöhnliche Variablen im Makefile zugegriffen werden, d. h. „New“ ist der Argumentwert der Variable „TARGET“.
ZIEL = Neu
Beispiel: Erstellen Sie die Variablen und Argumente
Um die Verwendung von Variablen und Argumenten im Makefile zu demonstrieren, verwenden wir ein einfaches Beispiel in C++. Wir erstellen eine neue C++-Datei in Notepad++ und fügen einen „iostream“-Header hinzu, um die Eingabe und Ausgabe in einem Beispielprogramm zu verwenden.
Die Funktion main() beginnt mit der Deklaration einer Zeichentypvariablen „v“. Der Standardausgabestream „cout“ wird verwendet, um den Benutzer anzuzeigen und ihn zur Eingabe aufzufordern. Im Gegensatz dazu erhält der Standardeingabestream „cin“ zur Laufzeit einen Eingabewert von einem Benutzer und speichert ihn in der Variablen „v“. Der Standardwert „cout“ wird wiederum verwendet, um den Wert anzuzeigen, der von einem Benutzer zur Laufzeit hinzugefügt wird. Die Anweisung „return 0“ beendet die Programmausführung erfolgreich.
#includeint main ( ) {
char v;
std::cout << „Geben Sie einen Wert ein:“ ;
std::cin >> In;
std::cout << In << std::endl;
zurückkehren 0 ;
}
Ein Makefile wird auf standardmäßige Weise generiert. Die allererste Variable, „CXX“, deklariert den Compiler, der zum Ausführen der C++-Datei verwendet werden soll, also „g++“. Die nächste Variable wird verwendet, um die Flags für einen Compiler zu setzen, um Probleme zu vermeiden.
Nun wird die Zieldatei über die Variable „TARGET“ auf „Neu“ gesetzt. Dies ist eine ausführbare Datei. Danach definiert das Makefile seine Quell- und Objektdatei über die SRCS- und OBJS-Variablen. Um die deklarierten Variablen zu nutzen, verwenden wir das Zeichen „$“, gefolgt von den Klammern „()“, um die ausführbare Zieldatei und die Zieldatei zu erstellen und das Objekt und die Zieldatei zu bereinigen.
CXX = g++CXXFLAGS = -std =c++ elf -Wand
ZIEL = Neu
SRCS = main.cpp
OBJS = $ ( SRCS:.cpp=.o )
alle: $ ( ZIEL )
$ ( ZIEL ) : $ ( OBJS )
$ ( CXX ) $ ( CXXFLAGS ) -Ö $ ( ZIEL ) $ ( OBJS )
% .Ö: % .cpp
$ ( CXX ) $ ( CXXFLAGS ) -C $ < -Ö $ @
sauber:
rm -F $ ( ZIEL ) $ ( OBJS )
Nachdem Sie C++ und sein Makefile gespeichert haben, starten Sie das CMD Ihres Systems, navigieren Sie in das Arbeitsverzeichnis und führen Sie die Make-Anweisung wie folgt aus. Es generiert die Objektdatei „main.o“ und die Zieldatei „New.exe“ für die Quellcodedatei. Wir haben vorerst keine Argumente für die Erstellung der Anweisungen vorgebracht.
machen
Beim Ausführen der Zieldatei wird der Benutzer zur Eingabe aufgefordert. Wir fügen das „h“-Zeichen bei der ersten Ausführung und „haha“ bei der zweiten Ausführung hinzu. Während die „v“-Variable nur die „character“-Werte akzeptiert, wird das „h“-Zeichen aus der „haha“-Zeichenfolge gespeichert und angezeigt.
New.exe
Lassen Sie uns die Make-Anweisung mit den Befehlszeilenargumenten ausführen, die an die Makefile-Variablen übergeben werden. Also ändern wir den Variablenwert „TARGET“ und übergeben „Test“ an ihn. Danach wird die Datei „Test.exe“ generiert und funktioniert genauso wie die Datei „New.exe“.
machen ZIEL =TestenTest.exe
Abschluss
In diesem umfassenden Leitfaden sind wir den Inhalt des Makefiles einzeln durchgegangen. Wir haben erläutert, wie man die Variablen in einem Makefile deklariert, wie man sie nutzbar macht und wie man ihren Wert zur Laufzeit mithilfe von Argumenten ändert. Zur Unterstützung unserer Erklärung haben wir ein einfaches Beispiel in C++ besprochen.