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

8

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?

Goodwin Lu
fonte
2
otimismo para o crescimento? :) bons hábitos? Isso pode entrar no território da opinião.
Jeff Schaller
digite makepara descobrir a resposta. faça um Makefile de modelo decente e apenas edite sua variável dos arquivos de origem. não há necessidade de digitar todo esse jazz.
User2497
eles são uma espécie de pesadelo para os grandes projectos, de forma honesta, eu diria que eles são única boa para pequenos projetos;)
Eevee
Eu poderia usar makefiles, mas não uso. Dividi meu código fonte do meu maior projeto (pessoal) em 10 arquivos, recompile o primeiro e o primeiro inclui #inclui os outros nove. Com a velocidade da recompilação, não importa para mim se tudo é recompilado toda vez.
2119 Jennifer Jennifer
1
Preguiça :-) makeé muito mais rápido um comando para escrever que a maioria dos outros, mesmo se você não criar um Makefile inteligente para dependências punho limpa :-)
Stephen Harris

Respostas:

11

Ao contrário de quê?

Suponha que você tenha um programa que você dividiu em dois arquivos, que você nomeou imaginativamente file1.cfile2.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?

G-Man diz que 'restabelece Monica'
fonte
Para projetos muito pequenos, gcc -O3 -march=native -fwhole-program *.c é basicamente bom para um ciclo de edição / compilação / perfil. Mas você ainda quer um Makefile para outras pessoas usarem. Ser capaz de usar -fwhole-programé uma vantagem divertida de compilar tudo junto, mas -fltonormalmente oferece as mesmas otimizações.
Peter Cordes
2
Depois de começar a adicionar opções à linha de comando do compilador (mesmo para um arquivo de origem), acho difícil lembrá-las da próxima vez. Ocasionalmente eu vou colocar um comentário no arquivo de origem, mas naquele momento eu deveria usar apenas um Makefile ...
Roger Lipscombe
@ger Lipscombe: E se você precisar compilar para diferentes ambientes, é tão simples quanto definir algumas macros em seu makefile. E com um pouco de criatividade, você pode conectar o comando make a uma tecla de função editior, capturar a saída em um arquivo e usar outra tecla para colocá-lo na posição de qualquer erro ...
jamesqf
15

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.

Rastreador de pilha
fonte
Eu uso makefiles mesmo em projetos não compilados. Eu crio regras 'falsas' que executam comandos complexos relevantes apenas para o diretório envolvido. Por exemplo: limpeza, instalação nos locais certos, instalação de imagens do docker. Isso apenas facilita.
anthony
5

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.


fonte
3

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.

user996142
fonte
1

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.

LinuxSecurityFreak
fonte
0

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.

Adam Barnes
fonte