Besser bool oder uint8_t für binäre Statusinformation ?

[Jan (Gast)]

Hallo Mikrocontrollergemeinde,

Ich programmiere MCUs in C und habe mir schon oft folgende Frage 
gestellt :

Ist es besser bool zu benutzen,  oder uint8_t um binäre 
Statusinformation zu Speichern oder Zurückzugeben? (Siehe kleines 
Beispiel)

 
//Lösung A: 
static inline bool EndPosition (void){
  return (bool)PINA&(1<<0);    //PINA0 - End position switch

//Lösung B:
static inline uint8_t EndPosition (void){
  return PINA&(1<<0);    //PINA0 - End position switch
}

int main()
{
  .
  ...
  while(!EndPosition)
  {
  StepperDrive();
  };
  
  ..
  .

Welches ist zu bevorzugen ?
Lösung A oder Lösung B ?

Ich vermute beides erzeugt den gleichen Maschinencode (Ich habe es aber 
nicht geprüft).
Gibt es Aspekte unter welchen Lösung A oder Lösung B besser ist?
Oder ist es wirklich egal?

Grüße und Danke im Voraus für Eure Antworten.

Jan

[Arno (Gast)]

Ich finde Lösung 1 schöner, weil zum einen der Quelltext mehr 
Informationen enthält, zum anderen weil für bool (soweit ich weiß) gilt: 
!!a == a. Für uint8_t gilt das nicht immer.

MfG, Arno

[achs (Gast)]

bool ist normalerweise vom typ int. und dieser Typ ist in c für diesen 
Prozessor der Default-Typ, in der Regel der schnellste.

Bei einem reinen 8-Bitter könnte bool jedoch Performance kosten.
Zudem kann 16 oder 32 Bit für eine binäre Info RAM kosten.

Dein Code ist zwar richtig (die Funktionen liefern 0 oder 1 zurück), der 
Quelltext sagt aber, dass es nur zufällig so ist.

Hättest Du ein Höherwertiges Bit getestet, so wäre der Rückgabewert 2, 4 
oder was auch immer. Das ist auch OK, nur ist der Rückgabewert dann 
strenggenommen nicht bool (0/1), sondern 0/!=0.

static inline bool EndPosition (void){
  return 0!=(PINA&(1<<3));    //PINA3 - End position Switch
}

oder einfach doppelt negieren

static inline bool EndPosition (void){
  return !!(PINA&(1<<3)); 
}

[Mikro 7. (mikro77)]

Jan schrieb:
>

>   return (bool)PINA&(1<<0);    //PINA0 - End position switch
>

Wenn schon boolean, warum dann nicht

return 0 != (PINA&(1<<0)) ;

[Peter D. (peda)]

bool ist schöner, da es ein Leser besser verstehen kann.
Als Inline ergibt sich kein größerer Code.
Als echte Funktion entsteht ein kleiner Overhead durch die Umwandlung 
von alles !0 in 1.

[Til S. (Firma: SEGGER) (til_s)]

Lösung C wenn es um Effizienz geht ;-)

Bei den meisten Calling Conventions wird der Return Wert einer Funktion 
in einem CPU Register zurückgegeben. Am effizientesten ist es, wenn die 
Variablenbreite des Return Wertes der Breite des Registers entspricht.

Also sagen wir du hast eine 8 Bit CPU mit 8 Bit breiten Registern und 
möchtest eine long zurückgeben. Das passt dann nicht mehr in ein 
Register, also ineffizient. Genauso wenn du eine 32 Bit CPU hast und 
einen 8 Bit Wert zurückgeben möchtest. Das passt zwar rein aber 
anschließend muss evtl. noch maskiert werden.
Bei den meisten CPU/Compiler Kombinationen entspricht der "int" Datentyp 
der CPU Registerbreite. Das gilt aber natürlich nur für 16/32 Bit CPUs. 
Bei einer 8 Bit CPU würdest du "char" nehmen. Aber Vorsicht, auch hier 
gibt es Ausnahmen, ich erinnere mich an den Renesas H8 und den Renesas 
Compiler. Der H8 ist eine 32 Bit CPU ist, aber ein "int" war nur 16 Bit 
groß.

Bei dir müsstest du schauen, wie bool implementiert ist. Es kann sein, 
dass es das gleiche wie uint8_t ist. Dann würde ich bool nehmen, wenn 
die Funktion eine true/false Wert zurückliefert und nicht einen Wert 
zwischen 0..255. Ich würde die Funktion dann aber auch 
IsEndPositionReached() oder so nennen.

[Johann L. (gjlayde)]

achs schrieb:
> bool ist normalerweise vom typ int.

Bei GCC ist es üblicherweise _Bool, und der ist 1 Byte groß (zumindest 
für: avr, arm, x86, x86_64).

[m.n. (Gast)]

Til S. schrieb:
> ich erinnere mich an den Renesas H8 und den Renesas
> Compiler. Der H8 ist eine 32 Bit CPU ist, aber ein "int" war nur 16 Bit
> groß.

Beim IAR Compiler waren (sind?) es 32 Bit ;-)

[Volker S. (vloki)]

Warum nicht einfach:
#define EndPosition PINA0

oder im Allgemeinen Bitfelder zum Speichern von binären Informationen?

Als Rückgabewert einer Funktion vielleicht aber doch bool,
wenn der Compiler das überhaupt unterstüzt ;-)

[Torsten R. (Firma: Torrox.de) (torstenrobitzki)]

Jan schrieb:
> Welches ist zu bevorzugen ?
> Lösung A oder Lösung B ?

A

> Gibt es Aspekte unter welchen Lösung A oder Lösung B besser ist?

Lesbarkeit, Robustheit, Ausdruck von Intention.

[Peter (Gast)]

Ich würde "bool" bevorzugen, da die Intention des Programmierers 
eindeutiger und das Programm somit lesbarer ist.

[Jan (Gast)]

Vielen Dank für die Zahlreichen Antworten.

Ich denke auch A ist die bessere Variante.
Vielleicht könnte man verallgemeinern das der gewählte Variablentyp 
immer dem Datentyp entsprechen sollte.
In diesem Fall möchte man einen „true“ oder „false“ zurückgeben, also 
ist bool die Richtige Wahl.

Til S. schrieb:
> Lösung C wenn es um Effizienz geht ;-)

Ist es tatsächlich so, dass die Lösung A unter Umständen nicht die 
effizienteste Lösung ist?
(Bei Verwendung moderner C-compiler.)
Ich dachte das durch das inlinen,  Lösung A immer die effizienteste 
Variante ist.

Volker SK schrieb :
> Warum nicht einfach:
> #define EndPosition PINA0

Funktionen sind Makros vorzuziehen.
Bei Makrofunktionen geht die Type-überprüfung verloren.


Gruss,
Jan

[beric (Gast)]

Lösung C ;-)

typedef enum {
  UNBEKANNT, AM_ENDE, UNTERWEGS
} Position;

Position wo_bin_ich(void)
{
  Position pos = UNBEKANNT;

  if(PINA&(1<<0)
    pos = UNTERWEGS;
  else if ...
    pos = AM_ENDE;
  
  return pos;
}

main()
{
  ...
  if(wo_bin_ich() == UNTERWEGS)
  {
     Stepper();
  }
  ...
}

[Johann L. (gjlayde)]

Jan schrieb:
> In diesem Fall möchte man einen „true“ oder „false“ zurückgeben,
> also ist bool die Richtige Wahl.

Naja, eigentlich will man zurückgeben, ob PINA.0 "low" oder "high" 
ist. Du gibst aber tatsächlich zurück "PINA.0 == high" :-)

Was gewollt ist, hängt von der Anwendung ab.

[Volker S. (vloki)]

Jan schrieb:
> Funktionen sind Makros vorzuziehen.
> Bei Makrofunktionen geht die Type-überprüfung verloren.

Ok ;-)