Qt in bestehendem Makefile-Projekt nutzen

Oliver Gast #4272652
Lesenswert?
• ▲
▼ 
Morgen zusammen,

ich hab hier ein eigenes C++ Projekt, dessen Funktionalität recht 
vollständig ist.
Der Buildprozess wurde noch per Hand als makefile geschrieben, weil ich 
aus der (embedded-) C-Ecke komme.
D.h. Compiler- und Linkeraufrufe sind irgendwo im makefile enthalten, 
ebenfalls die zu kompilierenden Sourcen und die zu linkenden 
zusätzlichen Libs (ncurses, etc.)

Die "GUI" ist momentan noch mittels ncurses umgesetzt. Allerdings ist 
sie recht locker an die "Geschäftslogik" angeflanscht, so dass man sie 
relativ einfach gegen eine andere GUI tauschen kann.
Die GUI enthält kaum Logik, sondern zeigt nur Daten an die über 
Schnittstellen von der Geschäftslogik geholt werden, oder gibt 
Nutzereingaben an diese weiter.

Nun würd ich gerne eine richtige GUI mittels Qt spendieren.
Die technische Umsetzung sollte weniger das Problem sein, wie gesagt, 
die GUI ist stark von der Logik abstrahiert.

Der Buildprozess stellt mich vor größeren Problemen.
Ich würde nur ungern alles komplett neu aufsetzen.
Allerdings verwendet ja Qt einen recht speziellen Buildprozess.
Makefiles werden dort eher weniger benutzt, stattdessen kommt qmake und 
der "moc" zum Einsatz.
Das sind Dinge, um die will man sich eher nicht selbst kümmern.
Ich hab zwar mal probeweise den moc händisch aufgerufen, aber schön ist 
das nicht.

Wie würdet ihr das Ganze angehen?
Wie kann ich Qt in mein bestehendes Projekt einbinden, ohne nur wegen Qt 
alles übern Haufen schmeissen zu müssen?

Gruß, Olli
Antwort Zitieren Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Beitrag melden
A. H. #4273516
Lesenswert?
• ▲
▼ 
Kein Problem. Ich habe Dir mal ein paar Regeln aus einem alten Makefile 
kopiert. Das sollte schon genügen. (Es war übrigens ein Projekt, bei dem 
das Executable wahlweise mit Qt- oder ncurses‑GUI gestartet werden 
konnte. Also auch das funktioniert.)

Wundere Dich nicht über einige Pfade. Ich lege Wert darauf, dass alles 
was gebaut wird, in einem eigenen Verzeichnis landet. Das erleichtert 
das Aufräumen und das Backup.

Den Backup-Teil habe ich mal drin gelassen. Wie Du siehst fahre ich nach 
jedem erfolgreichen Link ein einfaches Backup. Das dauert nur Sekunden, 
kostet meist auch nur einige Dutzend Kilobyte und ist das Backup, was 
mir bisher mit Abstand die meisten Kopfschmerzen erspart hat. Nur so als 
Anregung.


1
# how to make backups

2
define backup

3
        if test -f $(build)/.backup; then \

4
                find ./* -xdev -depth -follow -newer $(build)/.backup; \

5
                echo `date +%Y%m%d.%H%M%S`.diff >$(build)/.backup; \

6
        else \

7
                find . -xdev -depth; \

8
                echo `date +%Y%m%d.%H%M%S`.full >$(build)/.backup; \

9
                echo '### no backup timestamp found, full backup forced' 1>&2;\

10
        fi \

11
        | grep -v -e ^./$(build) -e ^./$(exec) >$(build)/.newfiles; \

12
        if test -s $(build)/.newfiles; then \

13
                backupfile=`cat $(build)/.backup`; \

14
                backupfile=$(backupdir)/$(backupname).cpio.$$backupfile.gz; \

15
                cat $(build)/.newfiles | cpio -o -a | gzip >$$backupfile; \

16
                echo '### backup:' `ls -sh $$backupfile` ;\

17
        else \

18
                echo '### no backup neccessary' 1>&2; \

19
        fi

20
endef

21


22


23
# by default build the executable and run an incremental backup if successful

24
all: $(exec)

25
        @$(backup)

26


27
# just build executable (no backup)

28
exec: $(exec)

29


30
# just compile (no linking and no backup)

31
compile: $(objects)

32


33
# run a full backup

34
backup:

35
        rm $(build)/.backup

36
        @$(backup)

37


38


39
# how to build the executable

40
$(exec): $(objects)

41
        $(cc) -o $@ $^ $(lflags)

42


43
# how to compile objects

44
$(objects): $(build)/%.o: %.cpp

45
        $(cc) -c $(cflags) $(incl) -o $@ $<

46


47
# how to create moc sources

48
$(qtsources): $(build)/%.moc.cpp: %.h

49
        $(moc) -o $@ $<

50


51


52
# how to build dependencies

53
$(depends): $(build)/%.dep: %.cpp

54
        @$(builddir)

55
        @echo 'creating $@'

56
        @$(cc) -MM $(cppflags) $(incl) $< >$@.tmp

57
        @sed 's/^$*.o/$(build)\/$*.dep $(build)\/$*.o/' $@.tmp >$@

58
        @rm $@.tmp

59


60


61
include $(depends)
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Thread beobachten

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

Bestehender Account

oder

Mit Google-Account einloggen

Noch kein Account?

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren