Quais são as vantagens de usar o make para pequenos projetos? [fechadas]

Vi que isso makeé útil para grandes projetos, especialmente com dependências confusas descritas em a Makefile, e também ajudando no fluxo de trabalho. Não ouvi vantagens em usar makepara pequenos projetos. Há alguns?

Ao contrário de quê?

Suponha que você tenha um programa que você dividiu em dois arquivos, que você nomeou imaginativamente file1.ce  file2.c. Você pode compilar o programa executando

cc file1.c file2.c -o yourprogram

Mas isso requer recompilar os dois arquivos todas as vezes, mesmo que apenas um tenha sido alterado. Você pode decompor as etapas de compilação em

cc -c file1.c
cc -c file2.c
cc    file1.o file2.o -o yourprogram

e, ao editar um dos arquivos, recompile apenas esse arquivo (e execute a etapa de vinculação, independentemente do que você alterou). Mas e se você editar um arquivo e depois o outro, e esquecer que editou os dois arquivos e recompilar acidentalmente apenas um?

Além disso, mesmo para apenas dois arquivos, você tem comandos de cerca de 60 caracteres. Isso rapidamente se torna tedioso para digitar. OK, claro, você pode colocá-los em um script, mas volta a recompilar todas as vezes. Ou você pode escrever um script realmente sofisticado e complicado que verifique quais arquivos foram modificados e faça apenas as compilações necessárias. Você vê para onde estou indo com isso?

Muitas outras pessoas estão entrando nos detalhes de makefiles mais complexos e na complexidade que os acompanha. Eu normalmente uso makefiles por um motivo completamente diferente:

Não quero me lembrar de nada.

Mesmo que seu projeto seja realmente chato e simples, e você não use makefiles "corretamente":

all:
    gcc main.c -o project

Não preciso pensar sobre isso ou tratá-lo de maneira diferente de um projeto mais complexo:

all:
    gcc libA.c libB.c main.c -o project2

Ou, se eu especificou sinalizadores (por exemplo -O2), não preciso lembrar o que eram.

Além disso, se você começar com um simples makefile e precisar mesclar / refatorar as coisas posteriormente, não precisará se lembrar de criar cada projeto de maneira diferente.

Mesmo em projetos pequenos, pode ser útil manter a lógica da dependência sob controle e criar automatizados. Eu também o usei para acionar instalações e desinstalações, por isso era um interruptor principal que redefinia o palco.

Se você vincular seu aplicativo a partir de 2 fontes ( .carquivos), não será necessário recompilar cada arquivo, mas apenas o arquivo alterado, se você estiver usando make.

Além disso, vou dar um exemplo do mundo BSD. Eles possuem estrutura de Makefiles baseados em sistema. Eles fornecem caminhos para os diretórios do sistema e têm metas para instalar o software e as páginas de manual.

Por exemplo, você acabou de escrever um beer.caplicativo e manual para ele chamado beer.6. Você cria Makefile:

PROG=   beer
MAN=    beer.6

.include <bsd.prog.mk>

..e ligar make install. Ele compila e instala automaticamente seu aplicativo /usr/bine compila e instala sua página de manual no local onde o manencontra. Você acabou de instalar seu aplicativo com um comando simples!

Muito conveniente e absolutamente transparente para quem conhece o BSD. Muito melhor que o script manual.

Exemplo Makefilepara meu projeto muito pequeno:getPixelColor

Ele faz exatamente o que o nome diz, usando dois argumentos opcionais, as coordenadas.

Eu gosto especialmente da maneira como as coisas ficam dependentes lá.

COORDS ?= 0 0

CXX := g++-8
CXXFLAGS := -std=c++17 -Wall -Wextra -Werror -Wpedantic -pedantic-errors
LDLIBS := -lX11
RM := rm -f

BIN := getPixelColor
SRC := $(BIN).cpp

$(BIN): $(SRC)
    $(CXX) $(CXXFLAGS) $(SRC) -o $(BIN) $(LDLIBS)

.PHONY: clean
clean:
    $(RM) $(BIN)

.PHONY: run
run: $(BIN)
    ./$(BIN) $(COORDS)

Como você pode ver, ele pode fazer tudo o que você precisa, sem digitar nada extra:

Uso

Você pode executá-lo desta maneira:

1. Limpe o binário antigo:

   make clean

2. Compile um novo binário:

   make

3. Execute o executável de 2 maneiras:

   • as coordenadas padrão [0,0]

     make run     # equals COORDS='0 0'

   • quaisquer coordenadas

     COORDS='5 6' make run

Makefiles podem ser extremamente úteis às vezes. Quanto maior o projeto, maior o benefício. Mas mesmo com esse meu menor projeto C ++, como você pode ver nos exemplos, você economiza muitas dores de cabeça.

makeé bastante confiável disponível. Se você distribuir seu projeto com a makefile, os usuários terão uma referência simples sobre como realizar tarefas da mesma maneira que você. O makefilepode ser mais do que apenas a compilação.

Tome um projeto que não requer compilação, por exemplo. Lembro-me de trabalhar em um projeto Python que tinha um comando make para limpar todos os .pycarquivos, um comando make para executar os testes, um para baixar uma cópia dos dados estáticos do servidor de desenvolvimento etc.