Bedingte Kompilierung für mehrere OS

[otze]

mittels templates brauch man auch nur an einer stelle einen einzigen parameter verändern, und man kann das ganze prog auf ein andres betriebssystem ausrichten, wenn man ein gutes design hat.
du musst stattdessen 1000 defines machen...auch nich wirklich schön.

[DrGreenthumb]

Nein, du hast es nicht verstanden. Es sind 2(!) defines und die brauchst du genauso, wenn du zusätzlich noch den Template-Kram rumbaust.

Probiert das ganze erstmal aus, bevor noch mehr solche Argumente kommen.

[otze]

ich brauch kein define.
ich ersetze nämlich in der main einfach einen template parameter, das programm kompiliert bei mir dann für ein komplett andres betriebssystem, weil der eine template parameter bewirkt, dass alle andren klassen die benutzt werden auch auf das betriebssystem umgeschaltet werden, dh ich hab in keinem header ein define, ich hab in der main kein define ich hab in keiner cpp ein define, sondern regel alles(!) über ein template(bzw über eine typliste, dann änder ich nur nen typedef)

Probier das ganze erstmal aus, bevor noch mehr solche Argumente kommen.

[DrGreenthumb]

otze schrieb:

ich brauch kein define.
ich ersetze nämlich in der main einfach einen template parameter

Das will ich sehen. Normalerweise gehören zu einer Klasse auch noch die benötigten Header. Und diese fügst du dann, für jedes Betriebssystem, überall dort ein wo die Klasse benutzt wird? Ganz toll.
Im übrigen will man keinen Quelltext anfassen müssen, wenn man mal eben für ein anderes BS neu compilieren möchte.

Probier das ganze erstmal aus, bevor noch mehr solche Argumente kommen.

Nein, so brauchst du mir nicht kommen. ICH habe nämlich längst die Situtation hinter mir und habe meine Erfahrungen gesammelt.

[DrGreenthumb]

Defines braucht man eigentlich wirklich nicht. Man kann dem Compiler auch sagen, welche Include-Verzeichnisse er nehmen soll und welche Dateien dazukompiliert werden sollen. So kann man die ganzen Entscheidungen einzig und allein dem Makefile überlassen.

[otze]

deine erfahrung und deine 2355 posts ändern aber nix an der tatsache, dass du hier hemmungslos vergisst die edit funktion zu gebrauchen, auch wenn nur wenige secs zwischen den posts liegen

btw:

#include "program.hpp"
int main{
    executeProgramm<linux>();
    executeProgramm<Windows>();
    executeProgramm<PlatformIndependend>();
    return 0;
}

was is schlimmer? in sonem code einen parameter zu ändern,oder im projekt die ganzen includes umzuändern?

[DrGreenthumb]

otze schrieb:

deine erfahrung und deine 2355 posts ändern aber nix an der tatsache, dass du hier hemmungslos vergisst die edit funktion zu gebrauchen, auch wenn nur wenige secs zwischen den posts liegen

Was soll der Blödsinn jetzt? Ich habe nicht mit Posts oder Erfahrung angegeben. Ich habe geschrieben, ihr sollt das erstmal ausprobieren weil ihr dann schon feststellen werdet, dass das ganze recht sinnfrei ist. Dann kommst Du und stellst meine Aussage als Unfug dar.

btw. habe ich das ganz bewusst in einen separaten Post geschrieben.

btw:

#include "program.hpp"
int main{
    executeProgramm<linux>();
    executeProgramm<Windows>();
    executeProgramm<PlatformIndependend>();
    return 0;
}

was is schlimmer? in sonem code einen parameter zu ändern,oder im projekt die ganzen includes umzuändern?

Du weißt was templates sind? Du weißt, dass Du dort auch einfach executeProgram_linux() etc. hättest schreiben können? Eigentlich solltest Du dann merken, dass es damit noch nicht getan ist.

Aber langsam wirds mir zu blöd. Leb ruhig weiter in deinem Irrglauben.

[ssm]

otze schrieb:

deine erfahrung und deine 2355 posts ändern aber nix an der tatsache, dass du hier hemmungslos vergisst die edit funktion zu gebrauchen, auch wenn nur wenige secs zwischen den posts liegen

btw:

#include "program.hpp"
int main{
    executeProgramm<linux>();
    executeProgramm<Windows>();
    executeProgramm<PlatformIndependend>();
    return 0;
}

was is schlimmer? in sonem code einen parameter zu ändern,oder im projekt die ganzen includes umzuändern?

zeig jetzt bitte deine "program.hpp" Datei, wo keine #define drin sind

[SideWinder]

Er machts ja so:

#define CURSES
#include "header.h"

int main ()
{
    foo_inheader(sonstwas);
    return(0);
}

// CHANGES FÜR NEUE PLATTFORM:
#define DOS // Statt #define CURSES

Bloß ist das unübersichtlich, verhindert das Makro DOS (Namespaces sind nicht möglich), ist imho eher C denn C++, muss unbedingt vor dem Include "header.h" definiert sein, etc.

MfG SideWinder

[otze]

ssm schrieb:

otze schrieb:

deine erfahrung und deine 2355 posts ändern aber nix an der tatsache, dass du hier hemmungslos vergisst die edit funktion zu gebrauchen, auch wenn nur wenige secs zwischen den posts liegen

btw:

#include "program.hpp"
int main{
    executeProgramm<linux>();
    executeProgramm<Windows>();
    executeProgramm<PlatformIndependend>();
    return 0;
}

was is schlimmer? in sonem code einen parameter zu ändern,oder im projekt die ganzen includes umzuändern?

zeig jetzt bitte deine "program.hpp" Datei, wo keine #define drin sind

klar gerne:

//programm.hpp
#include "windows.hpp"
#include "linux.hpp"
enum BS{//nur hier aus verständnisgründen
    windows,
    linux
};
template<BS Type>
class WindowController{
    private:
        Window<Type> window;
    public:
        typedef Window<Type>::handle handle;

        void openWindow();
        void closeWindow();
        handle getWindowHandle();
};
template<BS Type>
class Engine{ 
    private:
        Archive<fileManager<Type> > files;
        baseEngine<Type> engine;
    public:
        //ein paar ctors
        //und nochn paar funktionen

        void createNiceEffect();    
};
template<BS Type>
void ProgramExecute();

//program.cpp
template<BS Type>
void ProgramExecute(){
    WindowController<Type> a;
    a.openWindow;
    Engine<Type> b(a.getWindowHandle);
    b.createNiceEffect();//wollte ich schon immer mal schreiben ;)
    a.closeWindow; 
}
//windows.hpp
template<> class baseEngine<windows>{
     DXWrapper wrapper;
     //usw
};
//linux.hpp
template<> class baseEngine<linux>{
     OpenGLWrapper wrapper;
     //usw
};

ein parameter geändert, und damit gleich eine andre grundlage für die engine, eine andre art, das fenster zu öffnen und auch ein andres archivsystem. Und das alles ganz ohne defines

[DrGreenthumb]

Und wie ich schon mehrfach betont habe, ist das ganze absolut überflüssig und unnötig verkompliziert.

Und das alles ganz ohne defines

Ganz toll, nur leider fehlt da auch noch der Teil, weshalb in meiner Version überhaupt defines verwendet wurden. Nämlich die Möglichkeit von ausserhalb (also ohne den Quelltext verändern zu müssen) für eine andere Plattform zu kompilieren.

Aber wie schon gesagt, braucht man ja nichtmal die defines dafür. Man kann im Makefile auch sowas machen:

target=windows

all:
  gcc -I$(target) bla.c

Und dann erstellt man einen ordner für windows und einen für linux wo man dann jeweils eine "gui.h" reintut. Der Rest des Programms macht einfach #include <gui.h> und fertig.

[otze]

so wie du 2 ordner anlegen kannst, kann auch ich einfach 2 projekte anlegen, macht nit copy&paste in etwa den gleichen aufwand wie 2 ordner anlegen und dort die files reinwerfen
imho ist ein code der auf templates basiert auch sehr viel flexibler, als so ein executeprogramm_linux() kram wie du ihn vorgeschlagen hast.

[DrGreenthumb]

otze schrieb:

so wie du 2 ordner anlegen kannst, kann auch ich einfach 2 projekte anlegen, macht nit copy&paste in etwa den gleichen aufwand wie 2 ordner anlegen und dort die files reinwerfen

Nein, überhaupt nicht. Zwei Projekte sind völlig unwartbar und nicht mit dem zu vergleichen, was ich gepostet habe.

imho ist ein code der auf templates basiert auch sehr viel flexibler, als so ein executeprogramm_linux() kram wie du ihn vorgeschlagen hast.

So etwas habe ich nie vorgeschlagen. Das war deine Idee.

Flexibler ist bei den Templates überhaupt nichts. Es ist nur mehr Aufwand, wenn man mal was ändern will.

[ssm]

otze schrieb:

//windows.hpp
template<> class baseEngine<windows>{
     DXWrapper wrapper;
     //usw
};
//linux.hpp
template<> class baseEngine<linux>{
     OpenGLWrapper wrapper;
     //usw
};

jetzt zeig mir bitte DXWrapper oder OpenGLWrapper

[otze]

aufwand? ich erstell einfach ne neue instanz.zb in meinem letzten code das beispiel mit dem archiv: ich muss nur den filemanager verändern, das archiv selber bleibt komplett unangetastet. selbes spiel mit der engine, ich muss "nur" eine neue instanz der baseEngine anlegen,oder kann gleich die opengl version benutzen.

btw: den funktionsnamen ohne templates hast alleine du vorgeschlagen, und da kann man schon auf einiges schließen

achja schau mal die main an, wenn das nich wartbar ist^^ an der main muss nie rumgeschnippelt werden, sie ist einfach da, und ansonsten können alle objecte auf die gleichen dateien zugreifen.

@ssm bin ich dumm? ich saug mir doch jetzt nich mal eben nen wrapper aus den fingern.
es gibt keine defines, ende.

[DrGreenthumb]

otze schrieb:

template<BS Type>
class Engine{ 
    private:
        Archive<fileManager<Type> > files;
        baseEngine<Type> engine;
    public:
        //ein paar ctors
        //und nochn paar funktionen

        void createNiceEffect();    
};

und hier hast du mehr Aufwand, wenn du an der Schnittstelle was ändern willst. Einmal hier in der Wrapper-Klasse und einmal in der eigentlichen Klasse.

template<BS Type>
void ProgramExecute(){
    WindowController<Type> a;
    a.openWindow;
    Engine<Type> b(a.getWindowHandle);
    b.createNiceEffect();//wollte ich schon immer mal schreiben ;)
    a.closeWindow; 
}

Und wo ist jetzt der Vorteil zu

Window a;
    a.openWindow;
    Engine b(a.getWindowHandle);
    b.createNiceEffect();//wollte ich schon immer mal schreiben ;)
    a.closeWindow;

?

Genau, es gibt keinen.

[ssm]

[quote="otze"]aufwand? ich erstell einfach ne neue instanz.zb in meinem letzten code das beispiel mit dem archiv: ich muss nur den filemanager verändern, das archiv selber bleibt komplett unangetastet. selbes spiel mit der engine, ich muss "nur" eine neue instanz der baseEngine anlegen,oder kann gleich die opengl version benutzen.

btw: den funktionsnamen ohne templates hast alleine du vorgeschlagen, und da kann man schon auf einiges schließen

achja schau mal die main an, wenn das nich wartbar ist^^ an der main muss nie rumgeschnippelt werden, sie ist einfach da, und ansonsten können alle objecte auf die gleichen dateien zugreifen.

otze schrieb:

@ssm bin ich dumm?

wieso fragst du mich?

otze schrieb:

ich saug mir doch jetzt nich mal eben nen wrapper aus den fingern.

ich möchte sie einfach gerne sehen.

otze schrieb:

es gibt keine defines, ende.

wie du willst

[otze]

[quote="DrGreenthumb"]

otze schrieb:

template<BS Type>
class Engine{ 
    private:
        Archive<fileManager<Type> > files;
        baseEngine<Type> engine;
    public:
        //ein paar ctors
        //und nochn paar funktionen

        void createNiceEffect();    
};

und hier hast du mehr Aufwand, wenn du an der Schnittstelle was ändern willst. Einmal hier in der Wrapper-Klasse und einmal in der eigentlichen Klasse.

erweiterbarkeit nicht veränderung,ocp,klingelts? und wieso muss ich was am wrapper ändern? der is doch weggekapselt und weit weg,da is kein änderungsbedarf. ausser im bereich dieser klasse muss ich nie was ändern.

template<BS Type>
void ProgramExecute(){
    WindowController<Type> a;
    a.openWindow;
    Engine<Type> b(a.getWindowHandle);
    b.createNiceEffect();//wollte ich schon immer mal schreiben ;)
    a.closeWindow; 
}

Und wo ist jetzt der Vorteil zu

Window a;
    a.openWindow;
    Engine b(a.getWindowHandle);
    b.createNiceEffect();//wollte ich schon immer mal schreiben ;)
    a.closeWindow;

lesbarkeit,erweiterbarkeit,wartbarkeit,besser zu debuggen, da der template typ immer mit angezeigt wird reicht das? oder soll ich weiter machen?

templates sind einfach genial, du kannst mit nimialen aufwand maximale wiederverwendbarkeit erreichen,kleines beispiel?

Archive<fileManager<windows> > files;//filemapping etc,nich so doll wenn man nur mal schnell was auslesen will 
Archive<standardFileStream> streamFiles;

mach das mit deinem coding style nach, ohne eine typ redifinition zu riskieren

@ssm sorry hab da die smileys vergessen, ich reich sie hiermit nach :p (bitte in der reihenfolge an jedes satzende einfügen^^)

[DrGreenthumb]

otze schrieb:

erweiterbarkeit nicht veränderung,ocp,klingelts?

Nur insofern, dass du meine Variante immer noch nicht verstanden hast. Die kannst du nämlich genauso erweitern. Nur musst du dort nicht an verschiedenen Stellen ändern.

lesbarkeit,erweiterbarkeit,wartbarkeit,besser zu debuggen, da der template typ immer mit angezeigt wird reicht das? oder soll ich weiter machen?

Lesbarer ist dein Template-Kram nun ganz sicher nicht. Im Gegenteil. Die anderen Punkte sind unfug, da hat deine Version keinerlei Vorteile gegenüber meiner.

templates sind einfach genial, du kannst mit nimialen aufwand maximale wiederverwendbarkeit erreichen,kleines beispiel?

Nein, ich weiß was Templates sind.

Archive<fileManager<windows> > files;//filemapping etc,nich so doll bei großen dateien
Archive<standardFileStream> streamFiles;

mach das mit deinem coding style nach, ohne eine typ redifinition zu riskieren

"Mein coding style" ?

Hier geht es um bedingte Kompilierung, je nach OS. Das kann man zwar mit den Templates machen, aber es bringt eben keine Vorteile sondern machen das ganze nur komplizierter.

Das habe ich jetzt zum 10. Mal geschrieben. Mir wird das zu eintönig mit Dir. Soll sich mal jemand anderes dazu äussern.

[otze]

os bedingte compilierung und wiederverwendbarkeit gehen hand in hand,je weniger du direkt wiederverwenden kannst, desto mehr musst du bei der portierung von einem os auf das andere neuschreiben.

ich muss maximal was im untersten bereich wechseln, dort wos os spezifisch wird, der rest kann gleich bleiben, oder wenn die veränderungen zu drastisch sind, müsste man noch einzelne andere teile verändern, aber es sind verhältnismäißg wenig sachen.