projekt mit g++ unter linux compilern

[b_a_r_t]

hallo,
hab folgendes problem: in der fh haben wir das untenstehende programm gekriegt. mit devcpp und windows funzt das auch wunderbar, aber wie kann ich unter linux mit g++ ein projekt mit mehreren cpp dateien compilern?

main.cpp


#include <iostream>
#include "funk.h"

using namespace std;

int main()
{
double x;
for (x=0; x<=xr; x+= 0.1)
printf("%lf %lf\n", x,f(x));
return 0;
}


funk.cpp


#include "konst.h"

double xr = 1.5;
double f(double x)
{
return N*x;
}


funk.h


extern double xr;
double f(double x);


konst.h


#define N 2



schon mal danke im voraus!

[Donnerfalke]

Am einfachsten kannste sowas über ein Makefile machen.
Hier ne relativ gut erklärte Anleitung:
http://www.willemer.de/informatik/unix/make.htm

[b_a_r_t]

danke, ist genau des was ich gesucht hab.

[peschmae]

Wobei du dann unter Linux üblicherweise das Makefile nicht direkt selber schreibst. Wieso nicht? Zu kompliziert, aufwändig und unflexibel.

Etabliert hat sich autoconf/automake - eine Suite von Tools. Als Ergebnis davon kriegst du dann die (dir wohl bekannten) ./configure-Scripts die Makefiles generieren. Allerdings ist die unmöglich zu bedienen.

CMake scheint eine gute Alternative zu sein (http://www.mrunix.de/forums/showthread.php?t=51814).

Wobei für ein Projekt mit so wenigen Dateien ist natürlich ein händisch geschriebenes Makefile am effizientesten. :)

MfG Peschmä

[panzi]

Jo, es gibt viele autohell Alternativen. Wie angedeutet finden sehr sehr viele Leute die autotools EXTREM umständlich und kompliziert. Alternativen wie CMake, SCons (http://scons.org/) oder Waf (http://www.freehackers.org/~tnagy/bksys.html) (früher bksys) sind da viel praktischer.

CMake soll eben recht gut sein und wird ab Version 4 auch von KDE verwendet. Aber ich mag Scons lieber, obwohl es nicht so die ausgereiften "configure" Features hat. Aber es ist in Python geschrieben und lässt sich extrem flexiebel und einfach mit Python erweitern. Wegen der unzulänglichkeiten von Scons wurde die SCons-Erweiterung BKSYS entwickelt, welche dann zum SCons-Rewrite Waf wurde.

[tribad]

Ich wüsste nicht, warum man ein Makefile nicht selber schreiben kann. Ich mache alle Makefiles von Hand. Und die sind bei weitem nicht aufwendig. Es ist eben eine Frage was ich von einem Makefile erwarte.

Normalerweise soll es erkennen was alles zu machen ist, damit hinten das Programm rauskommt.
Es gibt default rules, die einfach schonmal da sind und wenn es nur für ein einfaches Programm sein soll, das aus drei Modulen besteht, dann ist das völlig unproblematisch.



PROJ=mkclass
OBJDIR=.
OBJS=main.o

SRC=main.cpp

INCLUDEDIR =\
../../libs

INCLUDEPATH=$(foreach dir, $(INCLUDEDIR), -I$(dir))

LIBDIR =\
../../libs

LIBPATH=$(foreach dir, $(LIBDIR), -L$(dir))

LIBRARIES = tool

EXTERNALLIBS=$(foreach lib, $(LIBRARIES), -l$(lib))

LIBS+=$(EXTERNALLIBS)

DEFINES+=-D__DEBUG

CFLAGS+=$(DEFINES) -pthread -Wall -O0 -g $(INCLUDEPATH) $(LIBPATH)
CXXFLAGS+=$(DEFINES) -pthread -Wall -O0 -g $(INCLUDEPATH) $(LIBPATH)

all : $(PROJ)

$(PROJ) : $(OBJS) depend
g++ -g $(LIBPATH) $(OBJS) $(LIBS) -o $(PROJ)

depend : $(SRC)
g++ $(CXXFLAGS) -M $(SRC) | gawk -- '{if (substr($$1,length($$1),1) == ":") {
print "$(OBJDIR)/"$$0} else {print}}' > depend

clean :
rm -f $(PROJ)
rm -f $(OBJS)
rm -f depend

-include depend


Das ist schon extrem Aufwendig, weil es meine eigenen Library Pfade berücksichtigt und einiges mehr.

Hier brauchst du nur oben die OBJS liste verlängern, dann würde das neue Modul automatisch mit übersetzt und gelinkt. Und wenn du die SRC liste entsprechend erweiterst, dann werden auch für das neue Modul die Abhängigkeiten automatisch erzeugt.

Ich kann keinen Aufwand entdecken, der nicht mehr ohne auto-tools machbar wäre.

[anda_skoa]

Makefile Generatoren ermöglichen die Benutzung von system- und/oder installationsspezifischen Pfaden, compilerspezifische Flags, etc.

Läßt sich natürlich alles auch händisch machen, aber der Aufwand ist dann doch größer als der Nutzen, vorallem wenn man in seiner gesamten Laufbahn mehr als ein Projekt machen wird.

Ciao,
_

[tribad]

Die Frage ist, ob man denn hochgradig portabel sein will und vor allem muß. Ich arbeite seit 20 Jahren in der Softwareentwicklung. Durch die Bank Projekte, die auf spezifische Hardware massgeschneidert sind. Da ist es wichtiger zu wissen, was in einem Makefile passiert als eine Portabilität zu haben, die keinem was nutzt.

Ich glaube, das ungefähr 90% der Projekte, aller Projekte die von Computerbenutzern begonnen werden, niemals auf einem System übersetzt werden für das das Makefile nicht mit wenigen Handgriffen angepasst werden kann.

Es ist leider so, das sich Heute keiner mehr Gedanken darüber macht, wie etwas funktioniert. Man nutzt es einfach nur. Das geht solange gut, bis mal etwas nicht so abläuft wie es soll. Dann sind alle die hochkomplexen automatischen Systeme nichts mehr Wert.

[panzi]

Es ist leider so, das sich Heute keiner mehr Gedanken darüber macht, wie etwas funktioniert. Man nutzt es einfach nur. Das geht solange gut, bis mal etwas nicht so abläuft wie es soll. Dann sind alle die hochkomplexen automatischen Systeme nichts mehr Wert.
Naja. Es ist aber auch ganz logisch warum man sich einfach nicht mehr dafür interessieren kann wie alles funktioniert. Dafür ist "alles" (das OS, das Buildsystem etc.) einfach zu viel. Da würde man zu sonst nix mehr kommen. Das Projekt muss zu dem und dem Termin fertig sein. Da kann man sich einfach nicht in allen Einzelheiten mit dem Buildsystem/den Makefiles herumschlagen. Da braucht man ein System das so viel wie möglich für einen erledigt und mit dem man schnell Resultate erzielt und fertig. Ist leider eine hektische Zeit. Ich würde mich gerne detaillierter mit vielen beschäftigen, aber selbst das Studium (Software & Information Engineering) alleine ist schon stressig genug.