If- Abfrage groeßer kleiner

[Hannes (Gast)]

Hallo,

gibts eine Möglichkeit, dass unten kürzer zu schreiben?

if ((x1-x2) > 30 && (x1-x2) < 100)

kann ich da das && irgendwie vermeiden und dieses kürzer schreiben,
gibts da irgendeinen Trick?

lg und vielen Dank für die Antworten

[Falk B. (falk)]

@ Hannes (Gast)

>gibts eine Möglichkeit, dass unten kürzer zu schreiben?
>if ((x1-x2) > 30 && (x1-x2) < 100)

Wozu? Wiviel Million mal pro Sekunde soll das geprüft werden? 
Wahrscheinlich ist der Comiler schlau genug (x1-x2) nur einmal 
auszurechnen und das Egebnis zwischen zuspeichern. Wenn nicht, dann eben 
so

int tmp;
tmp = x1-x2
if tmp>30 && tmp<100)

MfG
Falk

[Hannes (Gast)]

weniger Schreibarbeit, besseres Programm,

bei deiner Möglichkeit habe ich ja wieder ein && drinnen

[ARM-Fan (Gast)]

Spontan würde ich nein sagen.
Aber anschaulicher kann man es programmieren, damit
man auch in 2 Wochen noch auf den ersten Blick sieht,
was man da eigentlich gemeint hat.

z.B. so:

void BehandleWerteX1undX2(int x1, int x2)
{
  int differenz = x1 - x2;

  if (differenz < 30) return;
  if (differenz > 100) return;

  MachWasMitDenWerten(x1, x2);
}

Ich versuche solche tief verschachtelten Konstrukte wie:

if (a==0)
{
  if (b==3 && c==5)
  {
     if (d != a)
     {
        MachEndlichWas();
     }
  }
}

durch sowas wie oben zu vermeiden.

[Falk B. (falk)]

@ Hannes (Gast)

>weniger Schreibarbeit, besseres Programm,

Unsinn!

MFG
Falk

[Obelix (Gast)]

Es soll manche (nicht alle) Compiler geben die folgendes können:

if (30 < x < 100)

[schlonz (Gast)]

wenn man Folgendes hat:

int x;
...

if ( (x<0) && (x>x_max) )
 {...}

kann man das auch so machen:

if ( (unsigned int)x > x_max )
  {...}

bei zwei Schranken, muß man halt vorher den Wert x entsprechend 
anpassen, sodaß es mit dieser Methode auch funzt.

[Eddy C. (chrisi)]

Also quasi:

if ((unsigned)(x1-x2-30) < 70)
    TuEs();

Krass. Herrlich selbsterklärend aber cool. Bin unsicher, ob da noch 
irgendwo +1 oder -1 fehlt.

[Hannes (Gast)]

Geht nicht auch, dass ich ein #define definiere, also "#define name 
text" und im Text dan nur den namen aufrufe und zurückbekomme, ob x in 
den Grenzen liegt?

lg

[Rufus Τ. F. (rufus)]

> Es soll manche (nicht alle) Compiler geben die folgendes können:
>
> if (30 < x < 100)

Das kann jeder C-Compiler. Allerdings ist das Resultat nicht das 
erwartete.

[Karl H. (kbuchegg)]

Hannes wrote:
> Geht nicht auch, dass ich ein #define definiere, also "#define name
> text" und im Text dan nur den namen aufrufe und zurückbekomme, ob x in
> den Grenzen liegt?
>

#define IN_RANGE(x,min,max)  ((x) < (min) ? 0 : (x) > (max) ? 0 : 1)


void foo()
{
   if( IN_RANGE( a, 70, 100 ) )
     ....

Aber ob das klarer ist, ich weiss nicht :-)

Natürlich hätte man den ?: auch vermeiden können ...

#define IN_RANGE(x,min,max)  ((min) > (x) && (x) < (max))

... aber du wolltest ja kein &&

Wie immer gilt bei Makros: Vorsicht mit der Auswertung. Ein

   if( IN_RANGE( a++, 70, 100 ) )

geht kräftig in die Hose. Vermeidbar sind die Probleme mit einer
Funktion:

unsigned char InRange( unsigned char Value,
                       unsigned char Min, unsigned char Max )
{
  if( Value < Min )
    return FALSE;

  if( Value > Max )
    return FALSE;

  return TRUE;
}

Ein C Profi würde das aber so schreiben:

unsigned char InRange( unsigned char Value,
                       unsigned char Min, unsigned char Max )
{
  return (Value > Min) && ( Value < Max );
}

[Unbekannter (Gast)]

Diese ganzen InRange()-Ansätze haben das Problem, dass nicht klar ist, 
ob die Schranken nun zum Wertebereich dazugehören oder nicht.

Darum ist der eindeutigste Ansatz wohl:

void blafasel(int x1, int x2)
{
  int differenz = x1 - x2;

  if ( differenz > 30  &&  differenz < 100 )
  {
    // Mach was
  }
}

Grundsätzlich ist es eine gute Idee, Prädikaten einen eigenen Namen zu 
geben. Der Name sollte aber IMHO Anwendungsfall bezogen sein. Also z.B.:

const int abweichung_minimal = 30;
const int abweichung_maximal = 100;

uint8_t ist_regelabweichung_klein(int soll, int ist)
{
  int differenz = soll - ist;

  return differenz >= abweichung_minimal && differenz <= abweichung_maximal;
}

void berechne(int soll, int ist)
{
  if ( ist_regelabweichung_klein(soll, ist) )
    return;

  // Mache den Rest...
}

Zusätzlich können diese kleinen Prädikatfunktionen noch "static inline" 
deklariert werden.

[Rolf Magnus (Gast)]

> Diese ganzen InRange()-Ansätze haben das Problem, dass nicht klar ist,
> ob die Schranken nun zum Wertebereich dazugehören oder nicht.
>
> Darum ist der eindeutigste Ansatz wohl:
> void blafasel(int x1, int x2)

Naja...

[Stefan (Gast)]

Und jetzt das ganze für mich nochmal in ASM .   ;-))
Danke