O Linux fazer O comando é usado para construir e manter grupos de programas e arquivos do código-fonte. No Linux, é um dos comandos mais utilizados pelos desenvolvedores. Ele auxilia os desenvolvedores a instalar e compilar muitos utilitários a partir do terminal. Além disso, ele cuida do processo de compilação de projetos de grande porte. Isso economiza o tempo de compilação.
O motivo principal do comando make é dividir um programa grande em partes e verificar se ele precisa ser recompilado ou não. Além disso, emite as ordens necessárias para recompilá-los.
Nesta seção, usaremos programas C++, pois a linguagem de programação C++ é uma linguagem orientada a objetos, mas você pode usar qualquer linguagem instalada em sua máquina. Não se limita apenas aos programas; podemos usá-lo para descrever outras tarefas também.
Como funciona o comando make?
O comando make aceita alvos como argumentos. Esses argumentos são especificados em 'Makefile'. O makefile contém os alvos, bem como as ações associadas relacionadas a esses alvos.
Quando executamos o comando make, ele procura o makefile e o varre para encontrar o alvo e acessar suas dependências. Se as dependências não forem especificadas, ele procurará a dependência e a construirá. Ele construirá o alvo principal após a construção das dependências.
Por exemplo, se quisermos alterar apenas um arquivo fonte e executarmos o comando make; portanto, isso compilará apenas o arquivo objeto conectado a esse arquivo de origem. Isso economizará muito tempo na compilação final do projeto.
O que é Makefile?
O comando make invoca a execução do makefile. É um arquivo especial que contém os comandos shell que criamos para manter o projeto. O makefile contém alvos e comandos para execução. Não é permitido criar mais de um makefile. Recomenda-se criar um diretório separado para ele.
Ele monitora os arquivos recentes, portanto, atualize apenas os arquivos necessários. Se tivermos um programa grande com muitos arquivos fonte, devemos recompilar todos os arquivos dependentes. Portanto, pode ser um processo extremamente demorado.
O makefile possui uma lista de padrões. Esses padrões são úteis para o sistema entender qual comando queremos executar. Esses padrões estão divididos em duas partes e separados por uma nova linha. A primeira linha é a linha de dependência, e as linhas subsequentes são consideradas como ações ou comando S. Os comandos são separados por uma tabulação na nova linha.
O dependências especifique a relação de cada arquivo com os arquivos de origem. E a alvo é um arquivo executável e é criado após a execução do comando make.
Opções
O comando make facilita várias opções para torná-lo mais específico. Algumas opções importantes são as seguintes:
faça -p -f/dev/nulo.
Vamos entender alguns exemplos do comando make. Veremos o uso básico do makefile e, a seguir, criaremos alguns programas c++ e um makefile. Realizaremos algumas operações neles para entender melhor o comando make.
tutorial hadoop
Uso básico do comando make
Vamos entender o uso básico do comando make e isso pode ajudá-lo a entender como ele funciona.
Crie um diretório 'projeto' e mude o diretório para ele. Considere os comandos abaixo:
mkdir project cd project
Agora crie um 'Makefile' tendo o seguinte conteúdo para o primeiro programa:
say_hello: echo 'Hello World!'
No arquivo acima, say_hello é um alvo que se comporta como uma função em qualquer linguagem de programação, e echo será considerado uma ação. Deve ser lembrado que a ação deve ser escrita usando um ABA. O alvo e a ação juntos criam uma regra para o makefile. Agora, execute o comando make da seguinte forma:
Considere a saída abaixo:
Na saída acima, podemos ver que a própria operação de eco está sendo exibida. Se não quisermos exibir o comando echo na saída, execute o echo começando com '@' símbolo. Para suprimir o eco, atualize o conteúdo do makefile da seguinte forma:
registro numpy
say_hello: @echo 'Hello World!'
Considere a saída abaixo:
Um destino pode ser um arquivo binário que depende das ações.
Vamos adicionar mais alguns alvos, como gerar e listar no makefile. Atualize o makefile da seguinte maneira:
say_hello: @echo 'Hello World!' generate: @echo 'Creating files' touch file-{1..5}.txt list: @echo 'Listing files' ls Se executarmos o comando make, ele executará apenas o primeiro alvo porque é o alvo padrão do makefile. Considere a saída abaixo:
Podemos alterar o alvo padrão incluindo o conteúdo abaixo em nosso makefile:
.DEFAULT_GOAL := generate
Adicione-o à primeira linha do arquivo da seguinte forma:
O makefile acima considerará 'generate' como o objetivo padrão. Execute o comando make e a saída será a seguinte:
A opção DEFAULT GOAL executará apenas um destino para especificar mais de um destino para usar todas as opções. Para especificar mais de um destino, atualize a primeira linha do makefile da seguinte forma:
all: say_hello generate
Ele executará o destino especificado. Considere a saída abaixo:
Existe outra opção que nos permite executar todos os alvos. Se quisermos executar todos os alvos do makefile, atualize o arquivo da seguinte forma:
.PHONY: all say_hello generate list say_hello: @echo 'Hello World!' generate: @echo 'Creating files' touch file-{1..5}.txt list: @echo 'Listing files' ls O arquivo acima executará todos os alvos especificados. Execute o comando make, considere a saída abaixo:
Uso avançado do comando make
Vamos criar um projeto C++ contendo os arquivos main.cpp, function1.cpp, function2.cpp e um arquivo de dependência function.h.
O código dos arquivos é o seguinte:
'Algoritmo de Kruskal'
principal.cpp:
#include #include 'functions.h' int main() { print_hello(); std::cout<< std::endl; std::cout<< 'The factorial of 5 is' << factorial(5) << std:: endl; return 0; } função1.cpp:
#include 'functions.h' int factorial(int n) { if(n!=1) { return (n * factorial(n-1)); } else return 1; } função2.cpp:
#include #include 'functions.h' void print_hello() { std::cout << 'Hello World'; } funções.h:
void print_hello(); int factorial (int n);
Agora crie um arquivo executável do projeto acima executando o comando abaixo:
g++ main.cpp function1.cpp function2.cpp -o hello
O comando acima criará um arquivo executável 'olá' dos arquivos main.cpp, function1.cpp e function2.cpp.
Considere a saída abaixo:
A partir da saída acima, se for executada com sucesso, não fornecerá nenhuma saída.
Vamos realizar a mesma tarefa usando o makefile.
Crie um arquivo como Makefile e coloque o código abaixo nele.
all: g++ main.cpp function1.cpp function2.cpp -o hello
A palavra-chave all é usada para target e em nova linha coloque o mesmo comando com uma TAB acima para especificar a operação. Salve o arquivo. Considere o arquivo abaixo:
Para operar, execute o comando da seguinte forma:
ordem sql por data
make
O comando acima criará um arquivo executável ‘hello’ dos arquivos especificados. Considere a saída abaixo:
Vamos adicionar mais algumas tarefas ao Makefile. Adicionar uma tarefa 'compilar' do seguinte modo:
all: compile: g++ main.cpp function1.cpp function2.cpp -o hello
Para executar a tarefa compilar, execute o comando abaixo:
make compile
O comando acima executará a tarefa de compilação. Considere a saída abaixo:
Vamos realizar mais algumas tarefas em nosso makefile.
atualize o Makefile da seguinte maneira:
all: hello hello: main.o function1.o function2.o g++ main.o function1.o function2.o -o hello main.o: main.cpp g++ -c main.cpp function1.o: function1.cpp g++ -c function1.cpp function2.o: function2.cpp g++ -c function2.cpp clean: rm -rf *o hello
A partir do makefile acima, criamos três objetos como main.o, function1.o e function2.o. Além disso, fornecemos as dependências para os alvos main.o, function1.o e function2.o como main.cpp, function1.cpp e function2.cpp respectivamente. Todos os alvos executarão as tarefas especificadas nele. Também especificamos um alvo limpo para limpar todas as dependências e remover o arquivo executável.
Agora execute o comando make all para executar nosso novo makefile.
make all
Considere a saída abaixo:
A partir da saída acima, podemos ver que o comando executou primeiro main.o, function1.o e function2.o respectivamente. Ele criará o arquivo executável e de objetos dos arquivos fornecidos. Ele não executará o alvo limpo porque não o especificamos em hello. Considere os arquivos abaixo:
O comando make tem um processo de trabalho simples. Ele executou a opção all e foi para olá. Após a execução de hello, ele lê o alvo na sequência especificada. Ele pesquisou cada alvo e suas dependências e os executou na sequência.
Para remover os objetos e o arquivo executável, execute a tarefa de limpeza. Para realizar a tarefa de limpeza, execute o comando da seguinte forma:
make clean
Considere a saída abaixo:
O comando acima removerá todos os objetos e arquivos executáveis. Veja o snap abaixo do diretório:
Na imagem acima, podemos ver que limpamos nosso diretório.
Variáveis no comando make
Podemos definir as variáveis em nosso makefile. Para definir as variáveis, use o '=' operador. Por exemplo, se quisermos criar uma variável A e atribuir um comando gcc a ela, atribua-a como:
verifique a versão do java no linux
A=g++
Use-o da seguinte maneira em nosso makefile:
hello: hello.cpp ${A} hello.cpp -o hello É passado para o terminal como:
g++ hello.cpp -o hello
Podemos usar $(A) em vez de ${A}, pois ambos são tratados da mesma forma pelo script.
Comentários no makefile
Para adicionar um comentário no makefile, use o '#' símbolo. Por exemplo, para adicionar um comentário na seção de compilação, adicione-o como '# Isso irá compilar o programa .' Os comentários são ignorados pelo compilador.