if-Verzweigung optimieren

[Onan (Gast)]

Hallo,

habe folgende Verzweigung:

if (a == 1)
{
  x= 10;
  DoSomething;
} else if (a == 2)
  {
    x= 20;
    DoSomething;
  }
  else
  {
   /* Programm zu Ende */
  }

DoSomething sind Aktionen, die beide Zweige ausführen sollen. Die 
Aktionen benötigen also ( a==1) || (a == 2)

Ich möchte DoSomething aber nicht als Funktion einbauen. Wie kann ich es 
am sinnvollsten erreichen, dass ich den Code von DoSomething nicht 
zweimal abtippen muss?

Mir fällt spontan nur ein:

if ((a == 1) || (a == 2))
{
  DoSomething;
  if ( a == 1)
  { x = 10 }
  if (a == 2)
  { x = 20 }
}

Gibt es eine geschicktere Möglichkeit?

[Stefan B. (stefan)]

Geschickter im Sonn von lesbarer, dann vielleicht

if ((a == 1) || (a == 2))
{
  x = a * 10;  // vor DoSomething, wenn es dem 1. Code entsprechen soll
  DoSomething;
}

Ausführungstechnisch dürfte es keinen grossen Unterschied zu deiner 2. 
Variante machen.

Es ginge auch

if ((a == 1) || (a == 2))
{
  x = 10;  // vor DoSomething, wenn es dem 1. Code entsprechen soll
  if (a == 2) x += 10;
  DoSomething;
}

Oder wenn a nicht mehr gebraucht wird

if ((a == 1) || (a == 2))
{
  x = 0;
  while (a--)
    x += 10;
  DoSomething;
}

Und so weiter...

[Michael Wilhelm (Gast)]

In deiner 2. Version kann die Abfrage
if(a == 2)
umgeformt werden in eine else-Verzweigung von if(a == 1), da ja nur bei 
a == 1 oder 2 reingesprungen wird.

MW

[Armin Z. (Firma: spengergasse) (mors)]

Wie wäre es mit einem Switch?
evtl. hast dann nochmals in einer Methode/Funktion die du dann aufrufst 
wenn a oder b zutrifft, in den parametern den wert 10 bzw. 20 stehen


switch(zahlZuUeberpruefen)
{
  case 1:
    METHODENAUFRUF(10);

/*^^Wenn die Variabel "zahlZuUeberpruefen" gleich dem Wert vom case hat 
wird dieser eben ausgewählt und dann wird die darauf folgende Anweisung 
ausgeführt*/

  default:
    ANWEISUNG;

/*^^Statt default solltest du denke ich auch einfach "case 2" nehmen 
können, sonst bleibt alles gleich, default bedeutet eben einfach nur, 
wenn der Rest nicht zutrifft macht er den Standart durch.*/
}

hoffe ich hab dir helfen können bzw. ich hab dir nix falsches gesagt.


EDIT: bei DEINEM 2ten Vorschlag ist das iwie unlogisch wieso du 2x 
abprüfst du kannst da dann in dem Fall die äußere Abfrage komplett raus 
lassen und die beiden anderen dafür abfragen lassen

[Onan (Gast)]

>EDIT: bei DEINEM 2ten Vorschlag ist das iwie unlogisch wieso du 2x
>abprüfst du kannst da dann in dem Fall die äußere Abfrage komplett raus
>lassen und die beiden anderen dafür abfragen lassen

Les mein Posting nochmal richtig ;) Wenn ich die äußere Abfrage komplett 
rauslasse, muss ich DoSomething in beide Zweige tippen. Will ich aber 
nicht.

>Geschickter im Sonn von lesbarer, dann vielleicht
>
>if ((a == 1) || (a == 2))
>{
>  x = a * 10;  // vor DoSomething, wenn es dem 1. Code entsprechen soll
>  DoSomething;
>}

die Werte für a und x sind Beispiele. Im realen Code wird x jeweils eine 
Konstante zugewiesen, mit arithmetischen Operationen ist da nichts zu 
machen.

>In deiner 2. Version kann die Abfrage
>if(a == 2)
>umgeformt werden in eine else-Verzweigung von if(a == 1), da ja nur bei
>a == 1 oder 2 reingesprungen wird.

Stimmt. Ist das dann Prozessortechnisch optimaler?

[Jörg W. (dl8dtl) (Moderator)]

Wenn du schon keine Funktion nehmen willst (warum nicht?  kann man ja
auch inline machen), kannst du DoSomething allemal in einen Makro
hacken.  Sieht nicht sehr schön aus, aber funktioniert.

[I_ H. (i_h)]

a=0;
switch(a)
{
  case 2:    a=10;
  case 1:    a+=10;
             DoSomething;
             break;
      
  default:   // ...
}

[I_ H. (i_h)]

Oder noch einfacher und ohne Verschreiber:

switch(x=10, a)
{
  case 2:    x=20;
  case 1:    DoSomething;
             break;

  default:   // ...
}

Dafür nicht ganz so mächtig (wollte man zB. auch noch 3 behandeln, dann 
müsste wieder += her).

[Stefan E. (sternst)]

@ I_ H.:

Der OP hat doch schon geschrieben:
> die Werte für a und x sind Beispiele. Im realen Code wird x jeweils eine
> Konstante zugewiesen, mit arithmetischen Operationen ist da nichts zu
> machen.

[I_ H. (i_h)]

Siehe 2. Beispiel ;). Wobei im allg. Fall

if (a == ca)
{
  x= va;
  DoSomething;
} else if (a == cb)
  {
    x= vb;
    DoSomething;
  }
  else
  {
   /* Programm zu Ende */
  }

natürlich auch

switch(x=va, a)
{
  case cb:   x+=vb-va;
  case ca:   DoSomething;
             break;
      
  default:   // ...
}

funktioniert, was dann auch auf beliebig viele Fälle erweiterbar ist. 
Die Konstantenrechnungen werden eh wegoptimiert.