public class Tools {
public static boolean ifDings(int b){
if ((b-1) == 2 || (b-1) == 3 || (b-1) == 9 || (b-1) == 10 || (b-1) == 16)
return true;
return false;
}
}
ARadauer hat gesagt.:was genau macht #define?
#define EINE_KONSTANTE 1
#define MAKRO(a,b) (a>b)?a:b
#ifdef EINE_KONSTANTE
#define EINE_ZWEITE_KONSTANTE 5
#endif
#define DEBUG 1
[...]
#ifdef DEBUG
Log.debug("Dies ist ein Text, den keiner Lesen soll!");
#endif
#ifdef JAVA14
String bigDecimalValue = aBigDecimal.toString();
#else
#ifdef JAVA5
String bigDecimalValue = aBigDecimal.toPlainString();
#endif
public static boolean ifDings(int b)
{
int c = b - 1;
return c == 2 || c == 3 || c == 9 || c == 10 || c == 16;
}
public static boolean ifDings(int b)
{
return b == 3 || b == 4 || b == 10 || b == 11 || b == 17;
}
Sorry, aber Makros sind sch....e, kannst du ganz einfach durch search&replace nachbilden lolNeuer BeitragVerfasst am: 14. 03. 2008, 9:16 Titel: Zitieren
Druckversion downloaden (dieser Post)
ARadauer hat folgendes geschrieben::
was genau macht #define?
"Defines" sind etwas sehr praktisches - sogn. Präprozessorbefehle, die auch bedingt ausgeführt werden können.
Im Prinzip deklarieren sie Makros, also z.B. sowas:
Code:
1
2
3
4
5
6
7
8
9
#define EINE_KONSTANTE 1
#define MAKRO(a,b) (a>b)?a:b
#ifdef EINE_KONSTANTE
#define EINE_ZWEITE_KONSTANTE 5
#endif
und so weiter.
Vor allem aber (und das ist die Stärke von den Dingern) kann man damit eine bedingte Compilierung hinbekommen:
Code:
1
2
3
4
5
6
7
8
9
#define DEBUG 1
[...]
#ifdef DEBUG
Log.debug("Dies ist ein Text, den keiner Lesen soll!");
#endif
Wer "#define DEBUG 1" nun auskommentiert, verhindert den Compile aller DEBUG-Blöcke. Das ist echt was feines und daher ist es auch schade, daß es sowas in Java nicht gibt.
maki hat gesagt.:Sorry, aber Makros sind sch....e, kannst du ganz einfach durch search&replace nachbilden lol
Dein Beispiel zeigt das sehr schön, was passieren kann: Es werden verschiedene Quellcodes und dadurch verschiedene Versionen Produziert...
Wer das "Glück" hatte mit M$ VC zu arbeiten, weiss was ich meine
Oder hattest du schon mal das Erlebniss, dass der Produktiv Code abschmiert, aber sobald du debuggen willst, geht alles?
Schliesslich werden nicht nur dein Code anders übersetzt(Teile ausgelassen, Teile miteinbezogen), sondern auch noch andere Libs eingebunden (DEBUG Versionen), da kann es dann leicht sein das der Fehler in der DEBUG Konstellation nie auftritt..
Wieso "disqualifizierende Aussage"?Aus Deinem Post kann ich nur schließen, daß Du es nicht verstanden hast. Die erste disqualifizierende Aussage ist das mit dem Search&Replace. Die Makros für Funktionen kann man auch als static irgendwo ablegen - kein Thema, aber der Rest ist nicht mit S&R abzudecken.
Die Bibliothek von der ich spreche und mit welcher ich Probleme hatte, hiess: MFC *g*Ich kann nichts dafür, daß Entwickler nicht fähig sind - wer für den Mist, den er da programmiert, keine Verantwortung übernimmt, hat leider Pech gehabt.
Kann ich gar nicht nachvollziehen...Und nein, ich habe solche Probleme nie gehabt und sehr viel mit VC gearbeitet.
if (Log.isDebug(this.getClass().getName()) Log.debug(this.getClass().getName(), "Humpf" + o.toString() + "blabla" + o2.toString());
#ifdef JAVA14
String bigDecimalValue = aBigDecimal.toString();
#else
#ifdef JAVA5
String bigDecimalValue = aBigDecimal.toPlainString();
#endif
Ganz einfach SlaterB:SlaterB hat gesagt.:dein Argument 'dann leicht sein das der Fehler in der DEBUG Konstellation nie auftritt'
kann ich aber auch nicht nachvollziehen,
was kann man den im Macro-Debug-Modus so groß anders machen
als entsprechend in ein if (logger.isDebugEnabled() { }-Block zu schreiben,
warum ist log4j da besser?
Schlechtes Beispiel, schlecht (formatierter) Code wird nicht besser durch Macros...quippy hat gesagt.:1. log4j und bedingte Compiles haben nix miteinander zu tun. Das Problem bei Logausgaben ist nicht, daß sie hinterher im Log stehen - oder nicht, sondern daß für die Erstellung der Zeichenkette oftmals sehr viel Zeit drauf geht - obwohl man hinterher das Ergebnis gar nicht sehen will.
Alternativ kann man natürlich
wieder etwas Zeit sparen - aber mit der bedingten kompilierung wäre es gar nicht erst im Coding mit drin.Code:if (Log.isDebug(this.getClass().getName()) Log.debug(this.getClass().getName(), "Humpf" + o.toString() + "blabla" + o2.toString());
if (log.isDebugEnabled()) {
log.debug(wasAuchImmer);
}
Das ist doich ganz einfach: Entscheide dich für eine Java Versionquippy hat gesagt.:2. Das folgende Problem kannst Du gerne mal mit Suchen und ersetzen lösen:
Code:#ifdef JAVA14 String bigDecimalValue = aBigDecimal.toString(); #else #ifdef JAVA5 String bigDecimalValue = aBigDecimal.toPlainString(); #endif
Alternative: Reflection - wirklich sehr performant.
Dachte es wäre klar, offensichtlich noch nicht.du wiederholst nur die Tatsachen (andere Code-Version, Bibliotheken)
aber erklärst immer noch nicht, was sich daraus für Probleme ergeben können
Darum geht es doch gar nicht, es geht um folgendes:n Java wie in anderen Sprachen kompiliert man doch eh zigmal am Tag,
überall muss man darüber nachdenken, die alten Kompilate zu überschreiben oder separate unterschiedliche Versionen anzulegen
Das kannst du ja M$ fragenBibliotheken ist mir noch ein gänzlich unverständlicher Punkt,
wofür braucht eine Log-Ausgabe andere Bibliotheken?
Verstehe deine Frage nicht.wenn man mit Macros und unterschiedlichen Bibliotheken was anderes als Logging macht,
wie kann man das dann in log4j oder auf sonstige Weise ohne unterschiedliche Biblotheken machen?
Sicherlich nicht, aber genau das ist mir passiertnun das ist eine Info, einen VC-Debug-Modus, was immer das auch ist, sollte man demnach unter bestimmten Voraussetzungen nicht vertrauen,
aber hat des Nicht-Funktionieren denn etwas mit der Qualität des allgemeinen Macro-Konzept zu tun?
Trotzdem habe ich nur einen Quellcode und ein Kompilat, anders bei Macros.> kann ich doch in den 2 Versionen verschiedene Fehler haben, oder?
genausogut kannst in nur einem Java-Code verschiedene Fehler haben,
und zwar zum einen die, die innerhalb ein if (debug) {}-Blocks stehen + die außerhalb,
was ist der Unterschied/ Vorteil/ Nachteil?
3 mal weil es nicht durchgedrungen war, drücke mich anscheinend nicht klar genug aus.SlaterB hat gesagt.:> Der Unterschied: Der Code und das kompilat sind immer gleich.
oh, hattest du ja erst dreimal erwähnt, aber noch nie die Folge/ Relevanz
Dazu reicht es, eine Konfigeinstellung zu ändern.> Ich kann Unit tests für alles machen, nur eben nicht für nicht-vorhandenen Code, weil zB kein Macro ersetzt wurde.
du kannst keinen Code testen, der wegen eines ifs nicht ausgeführt wird,
aber dann:
> Dieses if mitzutesten ist kein Problem, wenn es denn sein müsste ...
hmm, ein erster Hauch eine Info,
Eben nicht, da es sich mit verwendeten Macros um ein anderes Proramm handelt, mit anderen Quellen, welches erst kompiliert werden muss, und unter umständen andere Fehler hat als die Prod Version.aber wie kann man sich das vorstellen? meinst du damit, das Programm im Debug-Log-Modus zu testen?
kann man ein Macro-Programm nicht genauso einfach mit eingeschalteten Macros testen?
Dann hast du etwas übersehen.bisher sehe ich nur ein Argument von dir, nämlich dem Aufwand beim Testen,
das ist natürlich respektabel, aber zum Verfluchen reicht das nun noch längst nicht icon_wink.gif
Performance ist es nicht was ich sagte und meinte.beide Versionen ständig zu testen, ob mit log4j oder Macros, macht eh keinen Sinn,
beides wird wenn nötig dann sowieso automatisch gemacht, keine manuelle Arbeit,
zu Performance/ Zeitaufwand hast du ja schon 'lol' geschrieben, da darfst du das jetzt fairerweise auch nicht anführen icon_wink.gif
"Aufwand beim testen" hatte ich nie geschrieben.na jedenfalls klingt 'Auwand beim Testen' bis jetzt noch besser als die anfänglichen Schreckensbilder
'sondern auch noch andere Libs eingebunden (DEBUG Versionen)'
+ direkt dahinter
'da kann es dann leicht sein das der Fehler in der DEBUG Konstellation nie auftritt..'
"langsames/schnelles Logging" ist eine reine Mutmassung, wie lange dauert eine if -Abfrage?der Unterschied 'langsames Logging, per Konfiguration dynamisch änderbar'
vs 'schnelles Logging, da zur Compilierzeit entschieden'
ist ein fundamentaler Unterschied und aus meiner Sicht die Wahl zweier akzeptable Alternativen
du schriebstmaki hat gesagt.:"Aufwand beim testen" hatte ich nie geschrieben.
maki hat gesagt.:2 mal Quellcode -> mehr Aufwand, jede einzelne "Version" muss geprüft werden.
[..]
Sicherlich muss ich nicht alle tests neu schreiben, aber der Aufwand ist größer.
Was hat Performance mit Programmieraufwand zu tun den ich habe, wenn ich tests für zwei Produkte schreiben muss?
Es ist schlicht, das man 2 Produkte testen muss.
Das Fehler in einer Version vorkommen können (und meist auch tun) und in einer anderen nicht, ignorierst/verniedlichst du einfach?
genausogut kannst in nur einem Java-Code verschiedene Fehler haben,
und zwar zum einen die, die innerhalb ein if (debug) {}-Blocks stehen + die außerhalb,
was ist der Unterschied/ Vorteil/ Nachteil?
maki hat gesagt.:Jedenfalls klingt für mich "Schade das es keine Macros in Java gibt" nicht anders als "Schade dass es keine operator Überladungen in Java gibt" und "Schade dass es keine Mehrfachvererbung in Java gibt"...
IMHO kommt das von Leuten, die sich noch nicht im Detail damit beschäftigt haben und den Pferdefuss den diese "features" haben noch nicht kennen.
Aber an ersteres kommt man inzwischen schon verdammt nahe dran - zu etwa 99.96% Experimental Observation of an extremely dark materialquippy hat gesagt.:b) es gibt kein Schwarz und Weiß
Bei dem einen habe ich zwei Programme (Debug & Prod), bei dem anderen nur ein einziges.wenn man mit Macros derart unterschiedliche Programme hat, dass man dafür unterschiedliche Tests braucht,
warum gilt dann das gleiche nicht auch für eingeschaltetes Logging (mit if-Blöcke) vs ausgeschaltetes Logging (ohne if-Blöcke)?
Ja, war aber die Retourkutsche für:Ohje - alle sind dumm, nur Du nicht, weil Du erleuchtet wurdest. Leuten zu unterstellen, Sie hätten sich mit einem Thema nicht auseinandergesetzt, nur weil sie nicht Deiner (und damit offensichtlich der falschen) Meinung sind, ist fahrlässig!
Ich gebe dir recht mit dem was du über Operatorüberladungen und Mehrfachvederbung sagtest, bist keiner von denen die es nicht verstanden haben, nehme zurück was ich gesagt habe.Aus Deinem Post kann ich nur schließen, daß Du es nicht verstanden hast. Die erste disqualifizierende Aussage ist das mit dem Search&Replace.
Ehrlich gesagt hab ich keine Ahnung worum es in diesem Thread *eigentlich* ging..(Ich find' der Thread war noch nicht off-topic genug icon_rolleyes.gif )
Der Unterschied ist der erzeugte (Quell)code.und ja, das setze ich gleich (auf einen gewissen abstracten Anwendungslevel), auf dem Stand können wir ja verbleiben