Jokertegn og Foreach i Makefile

Jokertegn Og Foreach I Makefile



En fil består alltid av en annen type innhold: enten det er en enkel tekstfil, en programkodefil eller en hvilken som helst makefil. Innholdstypen til enhver fil gjør den unik og skiller den fra det andre filformatet. Akkurat som det, makefile består av regler som bruker forskjellige elementer for å utføre arbeidet på riktig måte. Fra disse elementene er det jokertegnet og foreach som kreves for å utføre noe unikt og ekstra. I denne guiden vil vi diskutere kraften til jokertegn og foreach mens de brukes i en makefil.

Jokertegn i Makefile

Generelt er jokertegnet kjent for å være en faktor som ikke kan forutsies og kan snu situasjonen på alle mulige måter. Jokertegnene i makefilen brukes til å utføre en bonus ved å oppdage alle mulige mønstre fra en gjeldende arbeidskatalog, enten det er en fil eller en hvilken som helst mappe. Disse kildefilene kan være av hvilken som helst type.







For å bruke et jokertegn i en makefil, bør du bruke 'jokertegn'-nøkkelordet som følger stjernen '*' eller '?' tegnet og filtypen som er koblet til gjennom en prikk. Du kan også bruke '?' tegn for å søke etter et enkelt tegn og '*' for å matche et hvilket som helst antall tegn. Hele denne strukturen skal brukes innenfor parentesene og et '$'-tegn. For eksempel erklærer vi 'SRCS'-variabelen som får sin verdifil via jokertegnet. Dette jokertegnet ser etter alle filene med 'cpp'-mønsteret på slutten.





Foreach i Makefile

Foreach-funksjonen til makefile fungerer akkurat som en foreach-sløyfe i programmeringsspråk – iterer over elementene i en liste. Foreach-funksjonen i makefile utfører en bestemt handling på hvert element i en liste. Dette elementet kan være en variabel eller en hvilken som helst kildefil. For eksempel utdyper vi syntaksen til foreach-funksjonen i makefile via SOURCES-variabelen som inneholder en liste med tre kildefiler. Foreach-funksjonen bruker denne SOURCES-variabelen til å lage det samme navnet for tre objektfiler ved å iterere listen over kildefiler og lagre dem i en annen 'OBJECTS'-variabel. De to siste linjene viser hvordan en makefile-regel kan brukes til å lage en objektfil for hver C-fil etter iterasjon.





KILDER := fil1.c fil2.c fil3.c
OBJEKTER := $ ( foreach src,$ ( KILDER ) ,$ ( src:.c=.o ) )
$OBJECTS : % .O: % .c
$ ( CC ) $ ( CFLAGS ) -c $ < -O $ @

Eksempel 1: Bruk av jokertegn

For å vise illustrasjonen og virkemåten til jokertegn og for hver funksjon, introduserer vi en C++-fil. Denne 'salary.cpp'-filen startes med bruk av 'iostream'-overskriften for å tillate en jevn bruk av input- og outputstrømmer. Hovedmetoden erklærer en variabel 's' av heltallstype og 'cout'-setningen for å be om en inngangsverdi under kjøring. Standardinndatastrømmen 'cin' får verdien fra en bruker ved kjøring og lagrer den i variabelen 's'. 'Cout' viser den angitte verdien av en bruker på konsollskjermen.

#include
bruker navneområde std;
int main ( ) {
int s;
cout << 'Skriv inn lønn:' ;
spiser >> s;
cout << ' \n Lønn: ' << s << endl;
komme tilbake 0 ;
}



Vi starter makefilen med 'CXX'-variabelen som definerer kompilatoren for C++, og CXXFLAGS-variabelen holder flaggene for C++-kompilatoren. Variabelen EXECUTABLE inneholder navnet på en kjørbar 'hei'-fil som genereres etter kjøringen av en makefil. SRCS-variabelen henter alle C++-filene fra en gjeldende katalog ved å bruke jokertegnet '*' for å søke i ethvert mønster som slutter med '.cpp'. OBJS-variabelen inneholder navnene på objektfiler som skal opprettes ved hjelp av SRCS-variabelen, og erstatter 'cpp'-utvidelsen med 'o'. Standard 'alle'-målet bygger makefilen og det avhenger av EXECUTABLE-variabelen.

Den første regelen oppretter 'hei'-målfilen som avhenger av OBJS-variabelen (navn på objektfiler) objektfilen ved å bruke filnavnene som genereres via 'OBJS'-variabelen. Den andre makefile-regelen genererer objektfilen med '.o'-utvidelsen som avhenger av C++-filen etter kompilering av C++-kodefilen. Her er '%' et jokertegn for å søke etter filnavnene til ethvert mønster som slutter med 'cpp'. Til slutt bruker det rene målet sin 'rm'-kommando til å rense de nylig genererte kjørbare og objektfilene fra en katalog ved å bruke '-f'-flagget.

CXX = g++
CXXFLAGGER = -Vegg -std =c++ elleve
Kjørbar = hei
SRCS = $ ( jokertegn * .cpp )
OBJS = $ ( SRCS:.cpp=.o )
alle: $ ( Kjørbar )
$ ( Kjørbar ) : $ ( OBJS )
$ ( CXX ) $ ( CXXFLAGGER ) -O $ @ $ ( OBJS )
% .O: % .cpp
$ ( CXX ) $ ( CXXFLAGGER ) -c $ < -O $ @
ren:
rm -f $ ( Kjørbar ) $ ( OBJS )

Etter å ha kjørt 'make'-instruksjonen, ble både mål- og objektfilene opprettet. Etter å ha kjørt den kjørbare 'hei'-filen, blir brukeren bedt om å angi en lønn og vi legger til '67000'. På slutten vises lønnen tilbake.

gjøre

Eksempel 2: Bruke Foreach

Etter å ha brukt jokertegn, er det på tide å bruke foreach-funksjonen i makefile. Resten av makefile-koden er den samme. På linje 6 initialiserer vi en annen variabel som er 'NAMES' med en liste med tre verdier - Kate, Kim, Tim. Standard 'alle'-mål avhenger av EXECUTABLE-variabelen (målfilnavnet 'hei') og hver setning. «addprefix»-funksjonen itererer «NAMES»-variabelen for dynamisk å generere målnavnene ved å sette prefikset «run_» i starten av hvert navn i «NAMES»-listen.

Regelen på den åtte linjen indikerer at en utkjørbar målfil, dvs. hallo, er avhengig av 'OBJS'. '-o'-flagget genererer målutdatafilen ved hjelp av OBJS. Regelen på den tiende linjen genererer målobjektfilen ved å bruke kildefilene med 'cpp'-utvidelsen. For å gjøre det, brukes '-c'-flagget til å kompilere en kildefil og generere den relaterte objektfilen som er nødvendig for målgenereringen. På den trettende linjen bruker vi EXECUTABLE-variabelen for å generere utdata med forskjellige navn som starter med 'run_' som et prefiks. Til slutt vil de rene mål- og falske målene fjerne og rense objekt- og målfilene.

CXX = g++
CXXFLAGGER = -Vegg -std =c++ elleve
# kjørbar målfil
Kjørbar = hei
SRCS = $ ( jokertegn * .cpp )
OBJS = $ ( SRCS:.cpp=.o )
# Liste over navn
NAVN = Kate Kim Tim
# Mål
alle: $ ( Kjørbar ) $ ( addprefix run_, $ ( NAVN ) )
$ ( Kjørbar ) : $ ( OBJS )
$ ( CXX ) $ ( CXXFLAGGER ) -O $ @ $ ( OBJS )
% .O: % .cpp
$ ( CXX ) $ ( CXXFLAGGER ) -c $ < -O $ @
# Lag mål for hvert navn
løpe_ % : $ ( Kjørbar )
. / $ ( Kjørbar ) $*
ren:
rm -f $ ( Kjørbar ) $ ( OBJS )
# Falske mål
.PHONY: alt rent

Bruken av 'make'-instruksjonen genererer det kjørbare 'hello'-målet og kjører programmet for hvert navn som er spesifisert i 'NAMES'-variabelen.

gjøre

Du kan også endre utdataene dine ved å bruke navnet fra en liste med prefikset 'run_'.

Lag run_Kim

Konklusjon

Denne guiden diskuterte bruken av jokertegn og foreach-konsepter i makefilen mens syntaksen deres ble diskutert separat. Etter det diskuterte vi kodeeksemplene for å utdype hver av deres arbeid med utganger for å få filene med de samme utvidelsene og iterere verdiene i en variabelliste.