3 StructWerte auf 0 abfragen?

[Marion (Gast)]

Hallo,

kann man 3 Struktwerte auch anders auf 0 abfragen?

Mein struct-Array besteht aus 3 uint8_t Werten.

struct cRGB {uint8_t r; uint8_t g; uint8_t b; }
leds[10];

if(leds[0].r == 0 && leds[0].g == 0; leds[0].b == 0) { }

[Jim M. (turboj)]

if (!(leds[0].r | leds[0].g  | leds[0].b)) { }

[Steph M. (stephh)]

Was willst du damit erreichen? Man könnte beispielsweise die r,g und b 
aufaddieren und das ergebniss auf 0 überprüfen aber was solls bringen?

[Frank (Gast)]

Die Struct um ein Byte erweitern.
Eine Union darüber legen mit der Struct und einem uint32.

Dann kannst du nur auf das uint32 == 0 abprüfen.

[Jakob (Gast)]

Meintest du (3 Werte gleichen Typs auf NULL abfragen) das?

if(leds[0].r == 0 && leds[0].g == 0 && leds[0].b == 0) { }

Dann probier dies:

if ( (leds[0].r | leds[0].g | leds[0].b) == 0 ) { }

oder das:

if ( ! (leds[0].r | leds[0].g | leds[0].b) ) { }

Falls es der Compiler nicht schon selbst optimiert, spart
man einige Verzweigungen.

[Darius (Gast)]

struct _tagRGB
{
#ifdef (ALIGNMENT == INTEL)
   UINT8 R;
   UINT8 G;
   UINT8 B;
   UINT8 dummy;
#elif (ALIGNMENT == MOTOROLA)
   UINT8 dummy;
   UINT8 B;
   UINT8 G;
   UINT8 R;
#endif

} T_STRUCTRGB;

union RGB
{
   T_STRUCTRGB  asUINT8;
   UINT32       asUINT32;
} T_UNIONRGB;



T_UNIONRGB color;


if ( color.asUINT32 == 0 )

oder

if (   (color.asUINT8.R == 0)
    && (color.asUINT8.G == 0)
    && (color.asUINT8.B == 0))
{
}

[Frank (Gast)]

struct cRGB {uint8_t r; uint8_t g; uint8_t b; };
union ucRGB{uint32_t u32all; cRGB tRGB;};

ucRGB LEDs[10];

...

if( LEDs[i].u32all == 0 )
{
 ...
}

[Tom (Gast)]

Marion schrieb:
> kann man 3 Struktwerte auch anders auf 0 abfragen?

Warum? Damit es schwieriger zu lesen ist und die albernen 13373n Tricks 
irgendwann Bugs verursachen? So schlau wie die Heldenvorschläge hier ist 
der Compiler selbst...

bool is_black (const struct cRGB* p)
{
    return p->r == 0 && p->g == 0 && p->b == 0;
}


if (is_black(&leds[0])
{

}

[Elke (Gast)]

Tom schrieb:
> So schlau wie die Heldenvorschläge hier ist
> der Compiler selbst...

Was genau meinst du?

[Tom (Gast)]

Elke schrieb:
> Was genau meinst du?

Dass halbwegs aktuelle Compiler so gut optimieren können, dass man bei 
einer simplen Abfrage genau das hinschreiben kann, was man meint, und 
das Bitschubsen dem Compiler überlässt. Wenn man so programmiert, kann 
man das auch in einem Jahr noch lesen.

[Jakob (Gast)]

Da muss ich dem Tom zustimmen!

Mein Vorschlag kam, weil ich Hardware-Naher ASM-Bitfummler bin,
um GENAU zu wissen, wie viele Takte irgend eine Operation
braucht. In zeitlich eng begrenzten Anwendungen kann man damit
genau sagen, ob es noch SICHER funktioniert, oder eben MANCHMAL
nicht, wenn zufällig eine Interruptroutine mit ihre maximalen
Dauer dazwischenfunkt.

Ansonsten war ich auch schon erstaunt, wie gut mittelmäßiger
C-Code (selbst wenn er nicht so gut lesbar war, dass man nach
einem halben Jahr SOFORT sieht, worauf es ankommt) von guten
Compilern zeitlich optimiert wurde.

Ehrlich gesagt: Ich habe beim Lesen des ASM-Codes von
C-Funktionen schon einige Tricks gelernt, auf die ich nicht
so schnell selbst gekommen wäre!