Verkürzte If-Abfrage hier sinnvoll?

freakC++

Guten Abend zusammen,
da ich meinen Quelltext immer kurz halten möchte, greife ich häufiger mal auf die verkürzte If - Abfrage zu. Ich verwende sie meistens aber nur, um einfache Fallunterscheidungen wie Rückgabe des Betragwertes durchzuführen. Nun habe ich eine "längere" Zuweisung, doch ohne die verkürzte if Abfrage, wäre der Quelltext wieder um 6 Zeilen länger. Ist es "schön" auch hier eine solche verkürzte If Abfrage zu nutzen?

(xmin <=0) ? xbreite = AbsVal(xmin) + xmax : xbreite = -xmin + xmax;
 (ymin <=0) ? ybreite = AbsVal(ymin) + ymax : ybreite = -ymin + ymax;

Mit if und else wäre es eindeutig länger.

Vielen Dank
lg, freakC++

freakC++ schrieb:

Guten Abend zusammen,
da ich meinen Quelltext immer kurz halten möchte, greife ich häufiger mal auf die verkürzte If - Abfrage zu. Ich verwende sie meistens aber nur, um einfache Fallunterscheidungen wie Rückgabe des Betragwertes durchzuführen. Nun habe ich eine "längere" Zuweisung, doch ohne die verkürzte if Abfrage, wäre der Quelltext wieder um 6 Zeilen länger. Ist es "schön" auch hier eine solche verkürzte If Abfrage zu nutzen?
(xmin <=0) ? xbreite = AbsVal(xmin) + xmax : xbreite = -xmin + xmax;
 (ymin <=0) ? ybreite = AbsVal(ymin) + ymax : ybreite = -ymin + ymax;
Mit if und else wäre es eindeutig länger.

Vielen Dank
lg, freakC++

Finde das nicht mehr schön...

Sowas hier ist okay, aber bei ist das übertrieben...

std::cout << isActivated ? "on" : "off" << std::endl;

drakon

Also ich finds nicht schlimm. Ich verstehe bei einmaligem lesen, was du da machen willst, also ist da imo nix dran auszusetzen.

Nexus

freakC++ schrieb:

(xmin <=0) ? xbreite = AbsVal(xmin) + xmax : xbreite = -xmin + xmax;
(ymin <=0) ? ybreite = AbsVal(ymin) + ymax : ybreite = -ymin + ymax;

Wenn schon operator?: , dann richtig.

xbreite = (xmin <= 0) ? AbsVal(xmin) + xmax : -xmin + xmax;
ybreite = (ymin <= 0) ? AbsVal(ymin) + ymax : -ymin + ymax;

Oder ganz ohne Redundanz:

xbreite = xmax + (xmin <= 0 ? AbsVal(xmin) : -xmin);
ybreite = ymax + (ymin <= 0 ? AbsVal(ymin) : -ymin);

Und die Standard-Betragsfunktion std::abs() kennst du?

uhsuhz

ich würde es wahrscheinlich eher wie Nexus schreiben...

2. Mal so am Rande, was macht deine AbsVal-Funktion? Etwa den Absoluten Wert berechnen? also so wie abs?

Wenn ja, brauchst du nur:

xbreite = xmax - xmin;
ybreite = ymax - ymin;

Kommt auf das selbe raus, da abs von einer negativen Zahl -x ist, dann sind bei argumente gleich und das ganze Problem stellt sich nicht mehr...

drakon

Genau die Variante von Nexus finde ich unleserlich.
Da musste ich ein paar mal nach hinten und vorne springen, um zu sehen, was er da eigentlich machen will. :p

Bashar

freakC++ schrieb:

(xmin <=0) ? xbreite = AbsVal(xmin) + xmax : xbreite = -xmin + xmax;
 (ymin <=0) ? ybreite = AbsVal(ymin) + ymax : ybreite = -ymin + ymax;

Mit if und else wäre es eindeutig länger.

if (xmin <= 0) xbreite = AbsVal(xmin) + xmax; else xbreite = -xmin + xmax;

Stimmt, eindeutig länger.
?: ist nicht als verkürzte if-"Abfrage" gedacht, sondern als bedingter Ausdruck. Siehe Vorposter (Nexus).

Nexus

drakon schrieb:

Genau die Variante von Nexus finde ich unleserlich.
Da musste ich ein paar mal nach hinten und vorne springen, um zu sehen, was er da eigentlich machen will. :p

Soso. Und

(xmin <=0) ? xbreite = AbsVal(xmin) + xmax : xbreite = -xmin + xmax; 
(ymin <=0) ? ybreite = AbsVal(ymin) + ymax : ybreite = -ymin + ymax;

ist wahnsinnig übersichtlich, oder? :p

Wenn man den ternären Operator für ganze Anweisungen missbraucht, kann man genauso gut if nehmen, dann hat man wenigstens noch Syntaxhighlighting. Und die Zeilen zu trennen wäre wohl auch nicht allzu tragisch...

Nexus schrieb:

drakon schrieb:

Genau die Variante von Nexus finde ich unleserlich.
Da musste ich ein paar mal nach hinten und vorne springen, um zu sehen, was er da eigentlich machen will. :p

Soso. Und
(xmin <=0) ? xbreite = AbsVal(xmin) + xmax : xbreite = -xmin + xmax; 
(ymin <=0) ? ybreite = AbsVal(ymin) + ymax : ybreite = -ymin + ymax;
ist wahnsinnig übersichtlich, oder? :p

Wenn man den ternären Operator für ganze Anweisungen missbraucht, kann man genauso gut if nehmen, dann hat man wenigstens noch Syntaxhighlighting. Und die Zeilen zu trennen wäre wohl auch nicht allzu tragisch...

Und dann noch Klammern drum, um zu vermeiden, dass die später fehlen, falls man doch noch was machen will... Und dann wären wir bei meiner Definition von schönen Code

if (xmin <= 0) 
{
    xbreite = AbsVal(xmin) + xmax; 
{
else 
{
    xbreite = -xmin + xmax; 	
}

Schön != Kurz ;

freakC++

Hallo zusammen,
vielen Dank für die raschen Antworten. Ich gebe zu, dass mein Code hässlich war und dass Nexus ihn erstmal verschönert hat. Vielen Dank dafür. Wenn man irgendwie rumprobiert, dann achtete ich darauf irgendwie nicht und komme auf eine Schreibweise wie die von Nexus nicht. Die Funktion std::abs() kannte ich nicht ! Wieder was gelernt!

Die beste Lösung kommt aber eigentlich von uhsuhz. Wie wärs ganze ohne Fallunterscheidung ? Das ich das nicht sehe und dann kommen da solch komische Konstrukte heraus...

Ich kenne zwar die Regel Schön != Kurz, doch in diesem Fall denke ich dass gilt:

Schön == Kurz

weshalb ich uhsuhz Lösung nehme!

Vielen Dank euch allen
lg, freakC++

Sebastian Pizer

Muss uhsuhz recht geben. Sieht alles nach einer komplizierten Version von

breite = xmax - xmin;
hoehe  = ymax - ymin;

aus.

Und sonst würde ich Nexus' Variante vorziehen. Ich versuche auch immer den Teil um : so kurz wie möglich zu bekommen, indem ich Gemeinsames "ausklammere"...

Gruß,
SP

NES-Spieler

freakC++ schrieb:

da ich meinen Quelltext immer kurz halten möchte, greife ich häufiger mal auf die verkürzte If - Abfrage zu.

Das hat mich schon beim Lehrer meines PHP-Kurses genervt.
Bitte merke Dir: Der ternäre Operator ist nicht dazu da, als Kurzschreibweise für if und else zweckentfremdet zu werden. Benutze ihn nur, wenn Du den Rückgabewert wirklich brauchst. In Deinem Fall wäre, wie schon gesagt wurde, statt

(xmin <=0) ? xbreite = AbsVal(xmin) + xmax : xbreite = -xmin + xmax;

folgendes durchaus sinnvoll:

xbreite = xmin <= 0 ? AbsVal(xmin) + xmax : -xmin + xmax;

bzw.

xbreite = (xmin <= 0 ? AbsVal(xmin) : -xmin) + xmax;

Damit vermeidet man nämlich Redundanzen. Aber ein simples

if (Bedingung)
    Anweisung1();
else
    Anweisung2();

als

Bedingung ? Anweisung1() : Anweisung2();

schreiben, ist Zweckentfremdung allererster Güte. Der ternäre Operator ist nicht dazu da, den Code kürzer zu machen, sondern Dopplungen zu vermeiden: Bei

if (Bedingung)
    x = Wert1;
else
    x = Wert2;

könnte es ja passieren, daß ich nicht mehr x, sondern y zuweisen will. Dann müßte ich hier an beiden Stellen x durch y austauschen. Beim ternären Operator müßte ich das nur einmal machen:

x = Bedingung ? Wert1 : Wert2;

Oder auch solche Spielchen:

if (Bedingung)
    Funktion(1, 5, "Hallo", 7.9);
else
    Funktion(1, 22, "Hallo", 7.9);

Da benutzt man den ternären Operator nicht, weil er kürzer ist, sondern weil Redundanzen vermieden werden:

Funktion(1, Bedingung ? 5 : 22, "Hallo", 7.9);

Also: Den ternären Operator wirklich nur nehmen, wenn der Rückgabewert interessiert und nicht als Kurzschreibweise für if und else mißbrauchen.

freakC++

Jap, werde ich mir merken. Hier interessier jedoch der Rückgabewert, wehalb hier der tenäre Operator (heißt der so?) angebracht ist. Dennoch nehme ich nun gar keine Fallunterscheidung.

Vielen Dank
lg, freakC++