compilar - mínimo c++ make archivo para Linux

gcc linux

Question

Busco encontrar un simple archivo "mínimo" de c ++ makefile recomendado para Linux que usará g ++ para compilar y vincular un solo archivo y un archivo h. Lo ideal es que el archivo make ni siquiera tenga los nombres de los archivos físicos y solo tenga una transformación de .cpp a .o. ¿Cuál es la mejor manera de generar un archivo MAKE sin sumergirse en los horrores del autoconf?

El directorio actual contiene, por ejemplo

t.cpp th

y quiero un archivo MAKE para que se cree. Intenté autoconf, pero su suponer .h es gcc en lugar de g ++. Sí, aunque no soy un principiante, estoy volviendo a aprender desde hace años los mejores enfoques para la manipulación de proyectos y, por lo tanto, estoy buscando formas automatizadas para crear y mantener archivos MAKE para proyectos pequeños.

Answer 1

Algunas buenas referencias sobre la creación de un Makefile básico

http://en.wikipedia.org/wiki/Make_(software)

http://mrbook.org/tutorials/make/

http://www.opussoftware.com/tutorial/TutMakefile.htm

http://www.hsrl.rutgers.edu/ug/make_help.html

La primera pareja en particular tiene un mínimo de Makefiles de ejemplo como el que describió. Espero que ayude.

Answer 2

Si es un archivo único, puede escribir

make t

E invocará

g++ t.cpp -o t

Esto ni siquiera requiere un Makefile en el directorio, aunque se confundirá si tiene un t.cpp y un tc y un t.java, etc., etc.

También un Makefile real:

SOURCES := t.cpp
# Objs are all the sources, with .cpp replaced by .o
OBJS := $(SOURCES:.cpp=.o)

all: t

# Compile the binary ''t'' by calling the compiler with cflags, lflags, and any libs (if defined) and the list of objects.
t: $(OBJS)
    $(CC) $(CFLAGS) -o t $(OBJS) $(LFLAGS) $(LIBS)

# Get a .o from a .cpp by calling compiler with cflags and includes (if defined)
.cpp.o:
    $(CC) $(CFLAGS) $(INCLUDES) -c $<

Answer 3

Si sus problemas son porque autoconf cree que el archivo .h es un archivo ac, intente cambiarle el nombre a .hpp o .h ++

Answer 4

Suponiendo que no hay configuraciones de configuración preconfiguradas para todo el sistema:

CXX = g++
CPPFLAGS =        # put pre-processor settings (-I, -D, etc) here
CXXFLAGS = -Wall  # put compiler settings here
LDFLAGS =         # put linker settings here

test: test.o
    $(CXX) -o $@ $(CXXFLAGS) $(LDFLAGS) test.o

.cpp.o:
    $(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $<

test.cpp: test.h

Answer 5

¿Has mirado a OMake ?

OMakeroot

open build/C
DefineCommandVars()
.SUBDIRS: .

OMakefile

.DEFAULT: $(CXXProgram test, test)

Luego, en Linux o Windows, simplemente escriba:

omake

Como bonificación, obtiene automáticamente:

• compilaciones paralelas con la opción -j (igual que make).
• Sumas de comprobación de MD5 en lugar de marcas de tiempo (la construcción se vuelve resistente a las fallas de sincronización de tiempo).
• Dependencias de encabezado C / C ++ automáticas y precisas.
• Precisas dependencias entre directorios (algo que recursive make no ofrece).
• Portabilidad (1 cadena de construcción para gobernarlos a todos, inmune a los problemas de estilo de ruta).
• Un lenguaje de programación real (mejor que GNU make).

Answer 6

SConstruct con la opción de depuración:

env = Environment()

if ARGUMENTS.get(''debug'', 0):
    env.Append(CCFLAGS = '' -g'')

env.Program( source = "template.cpp" )

Answer 7

¿Has mirado a SCons ?

Simplemente crea un archivo SConstruct con lo siguiente:

Program("t.cpp")

Luego escribe:

scons

¡Hecho!

Answer 8

florin tiene un buen punto de partida. No me gn autoconf gnu así que comencé allí y llevé el concepto más allá y lo llamé MagicMakefile. Tengo 3 versiones de simple a más compleja. Lo último está ahora en github: https://github.com/jdkoftinoff/magicmake

Básicamente, supone que tiene un diseño estándar para los archivos fuente de su proyecto y usa la función de comodín para crear las reglas de makefile sobre la marcha que luego son evaluadas, manejando dependencias de archivos de cabecera, compilación cruzada, pruebas unitarias, instalación y embalaje.

[edit] En este punto, uso cmake para todos mis proyectos, ya que genera archivos de proyecto útiles para muchos sistemas de compilación.

jeff koftinoff

Answer 9

un Makefile GNU bastante pequeño, usando reglas predefinidas y autodeps:

CC=c++
CXXFLAGS=-g -Wall -Wextra -MMD
LDLIBS=-lm
program: program.o sub.o
clean:
    $(RM) *.o *.d program
-include $(wildcard *.d)

Answer 10

Aquí hay un archivo MAKE genérico de mi directorio de fragmentos de código:

SOURCES=$(wildcard *.cpp)
OBJECTS=$(SOURCES:.cpp=.o)
DEPS=$(SOURCES:.cpp=.d)
BINS=$(SOURCES:.cpp=)

CFLAGS+=-MMD
CXXFLAGS+=-MMD

all: $(BINS)

.PHONY: clean

clean:
    $(RM) $(OBJECTS) $(DEPS) $(BINS)

-include $(DEPS)

Siempre que tengas una fuente .cpp produciendo un binario, no necesitas nada más. Solo lo he usado con GNU make, y la generación de dependencias usa la sintaxis gcc (también compatible con icc). Si está utilizando los compiladores de SUN, debe cambiar "-MMD" a "-xMMD". Además, asegúrese de que la pestaña al comienzo de la línea después de clean: no se cambie a espacios cuando pegue este código o make le dará un error de separación faltante.