Menu

Tutorial de C ++ Makefile: Como criar e usar Makefile em C ++

  • Principal
  • Outro
  • Tutorial de C ++ Makefile: Como criar e usar Makefile em C ++

c makefile tutorial

Experimente Nosso Instrumento Para Eliminar Problemas

Neste tutorial do Makefile C ++, discutiremos os principais aspectos da ferramenta Make e do makefile, incluindo suas vantagens e aplicações em C ++:

Em qualquer projeto C ++, um dos objetivos importantes é simplificar a construção do projeto de forma que obtenhamos todas as dependências e arquivos do projeto em um lugar e os executemos de uma vez para obtermos a saída desejada com um único comando.

Perguntas e respostas da entrevista com técnico de suporte de desktop

Ao mesmo tempo, sempre que qualquer um dos arquivos do projeto é modificado, não precisamos ter o trabalho de construir todo o projeto novamente, ou seja, sempre que um ou dois arquivos são modificados no projeto, reconstruímos apenas esses arquivos alterados e, em seguida, prosseguimos com a execução.

=> Leia a série de treinamento Easy C ++.

Esses são exatamente os recursos que são endereçados pela ferramenta “make” e “makefiles” em C ++. Neste tutorial, discutiremos todos os principais aspectos dos makefiles, bem como seus aplicativos em C ++.

C ++ Makefile e ferramenta Make

O que você aprenderá:

Ferramenta de fabricação

Make é uma ferramenta UNIX e é usada como uma ferramenta para simplificar a construção de executáveis ​​a partir de diferentes módulos de um projeto. Existem várias regras que são especificadas como entradas de destino no makefile. A ferramenta make lê todas essas regras e se comporta de acordo.

Por exemplo, se uma regra especifica alguma dependência, a ferramenta make incluirá essa dependência para fins de compilação. O comando make é usado no makefile para construir módulos ou limpar os arquivos.

A sintaxe geral do make é:

%make target_label #target_label is a specific target in makefile

Por exemplo , se quisermos executar comandos rm para limpar arquivos, escrevemos:

% make clean #aqui clean é um target_label especificado para comandos rm

C ++ Makefile

Um makefile nada mais é do que um arquivo de texto usado ou referenciado pelo comando ‘make’ para construir os destinos. Um makefile também contém informações como dependências de nível de origem para cada arquivo, bem como as dependências de ordem de construção.

Agora vamos ver a estrutura geral do makefile.

Um makefile normalmente começa com declarações de variáveis ​​seguidas por um conjunto de entradas de destino para construir destinos específicos. Esses destinos podem ser .o ou outros arquivos executáveis ​​em C ou C ++ e arquivos .class em Java.

Também podemos ter um conjunto de entradas de destino para executar um conjunto de comandos especificados pelo rótulo de destino.

Portanto, um makefile genérico é mostrado abaixo:

# comment target: dependency1 dependency2 ... dependencyn command # (note: the in the command line is necessary for make to work)

Um exemplo simples do makefile é mostrado abaixo.

# 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

No makefile acima, especificamos dois rótulos de destino, o primeiro é o rótulo 'todos' para construir executáveis ​​a partir de arquivos de objeto myprogram e mylib. O segundo rótulo de destino ‘limpar’ remove todos os arquivos com o nome ‘meuprograma’.

Vamos ver outra variação do 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)

Conforme mostrado no exemplo acima, neste makefile usamos a variável ‘CC’ que contém o valor do compilador que estamos usando (GCC neste caso). Outra variável ‘CFLAGS’ contém os sinalizadores do compilador que usaremos.

A terceira variável ‘TARGET’ contém o nome do programa para o qual precisamos construir o executável.

A vantagem dessa variação do makefile é que precisamos apenas alterar os valores das variáveis ​​que usamos sempre que houver alguma alteração no compilador, sinalizadores do compilador ou nome do programa executável.

Exemplo de Make e Makefile

Considere um exemplo de programa com os seguintes arquivos:

  • Main.cpp: Programa de driver principal
  • Point.h: Arquivo de cabeçalho para classe de ponto
  • Point.cpp: Arquivo de implementação de CPP para classe de ponto
  • Square.h: Arquivo de cabeçalho para classe quadrada
  • Square.cpp; Arquivo de implementação CPP para classe quadrada

Com os arquivos .cpp e .h fornecidos acima, precisamos compilar esses arquivos separadamente para gerar arquivos .o e, em seguida, vinculá-los ao executável denominado main.

A seguir, compilamos esses arquivos separadamente.

  • g ++ -c main.cpp: gera main.o
  • g ++ -c point.cpp: gera um ponto.o
  • g ++ -c square.cpp: gera quadrado.o

Em seguida, vinculamos os arquivos-objeto para gerar o executável principal.

g ++ -o main main.o point.o square.o

A seguir, precisamos decidir quais arquivos teremos que recompilar e regenerar quando certas partes do programa forem atualizadas. Para isso, teremos um gráfico de dependência que mostra várias dependências para cada um dos arquivos de implementação.

A seguir está o gráfico de dependência para os arquivos acima.

gráfico de dependência

Portanto, no gráfico de dependência acima, podemos ver o executável ‘main’ na raiz. O executável ‘principal’ consiste em arquivos de objeto viz. main.o, point.o, square.o que é gerado pela compilação de main.cpp, point.cpp e square.cpp respectivamente.

Todas as implementações cpp usam arquivos de cabeçalho como mostrado no gráfico acima. Conforme mostrado acima, main.cpp faz referência a point.h e square.h, pois é o programa driver e usa classes de ponto e quadrado.

O próximo arquivo point.cpp faz referência a point.h. O terceiro arquivo square.cpp faz referência a square.h bem como ao point.h, pois também precisará de um ponto para desenhar o quadrado.

No gráfico de dependências acima, fica claro que sempre que qualquer arquivo .cpp ou arquivo .h referenciado por um arquivo .cpp for alterado, precisamos gerar novamente esse arquivo .o. Por exemplo, quando o main.cpp muda, precisamos gerar novamente o main.o e vincular os arquivos objeto novamente para gerar o executável principal.

Todas as explicações acima que demos funcionarão perfeitamente se houver poucos arquivos no projeto. Quando o projeto é enorme e os arquivos são grandes e muitos, torna-se difícil regenerar os arquivos repetidamente.

Assim, partimos para fazer arquivos e utilizamos para fazer uma ferramenta para construir o projeto e gerar o executável.

Já vimos várias partes de um arquivo make. Observe que o arquivo deve ser denominado “MAKEFILE” ou ‘makefile’ e deve ser colocado na pasta de origem.

Agora vamos escrever o makefile do exemplo acima.

Definiremos variáveis ​​para conter os valores do compilador e sinalizadores do compilador conforme mostrado abaixo.

CC = g++ CFLAGS = -wall -g

Em seguida, criamos o primeiro destino em nosso makefile, ou seja, o executável principal. Portanto, escrevemos um destino com suas dependências.

main: main.o point.o square.o

Assim, o comando para gerar este alvo é

$(CC) $(CFLAGS) –o main main.o point.o square.o

Observação: O comando acima realmente se traduz em g ++ -wall –g –o main main.o point.o square.o

Nosso próximo objetivo será gerar arquivos de objeto, main.o, point.o, square.o

Agora, para gerar main.o, o destino será escrito como:

Main.o: main.cpp point.h square.h

O comando para este alvo é:

$(CC) $(CFLAGS) –c main.cpp

O próximo arquivo point.o pode ser gerado usando o comando abaixo:

$(CC) $(CFLAGS) –c point.h

No comando acima, pulamos point.cpp. Isso ocorre porque o make já sabe que os arquivos .o são gerados a partir dos arquivos .cpp, portanto, apenas .h (incluir arquivo) é suficiente.

Da mesma forma, square.o pode ser gerado com o seguinte comando.

$(CC) $(CFLAGS) –c square.h point.h

Todo o makefile para este exemplo terá a seguinte aparência:

# 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

Assim, vemos que temos um makefile completo que compila três arquivos C ++ e então gera um executável principal a partir dos arquivos objeto.

Vantagens de Makefiles

  • Quando se trata de grandes projetos, usar makefiles nos ajuda a representar o projeto de uma forma sistemática e eficiente.
  • Makefiles tornam o código-fonte mais conciso e fácil de ler e depurar.
  • Os makefiles compilam automaticamente apenas os arquivos que são alterados. Portanto, não precisamos regenerar todo o projeto quando algumas das partes do projeto são modificadas.
  • A ferramenta Make nos permite compilar vários arquivos de uma vez para que todos os arquivos possam ser compilados em uma única etapa.

Conclusão

Makefiles são uma benção para o desenvolvimento de software. Usando um makefile C ++, podemos construir soluções em menos tempo. Além disso, quando uma parte do projeto é modificada, o makefile recompila e regenera apenas essa parte, sem ter que regenerar o projeto inteiro.

O Makefile C ++ nos permite representar o projeto de forma sistemática e eficiente, tornando-o mais legível e fácil de depurar.

Neste tutorial do Makefile C ++, vimos o makefile e as ferramentas do make em detalhes. Também discutimos como escrever um makefile do zero.

=> Confira o guia de treinamento perfeito C ++ aqui.

Leitura recomendada

^