boolean in C Hilfe

[Ben (Gast)]

Habe heute mit erstaunen festgestellt dass es gar keinen "boolean" in C 
gibt! bräuchte die aber eigetnlich unbedingt um Platz zu sparen. weiss 
da jemand eine Abhilfe, was benutzt man anstatt bool in C?

[Stefan M. (Gast)]

Nimm

#include <stdbool.h>

und verwende den Datentyp bool. true und false sind dann auch definiert.

mfg, Stefan.

[Greg (Gast)]

Hallo Ben,

ich benutze dann   unsigned char

Gruß,
Greg.

[Klaus F. (kfalser)]

> bräuchte die aber eigetnlich unbedingt um Platz zu sparen

Boolean sparen nicht unbedingt Platz. Es wird von der Implementierung 
abhängen, aber ich vermute der Platzbedarf entspricht einem integer, 
bestenfalls aber ein Byte.

[Stephan (Gast)]

@ Stefan May
Das nächste mal lies doch bitte die Fragestellung, dann wirst du dir 
solche Antworten in Zukunft verkneifen.

So nun zu Ben's Problem. Ein bit allein brauchen das wird schwer, hast 
du abere meherere bits so kannst du diese in einem Bitfeld ablegen.
z.B.

struct{
   unsigned bit7 : 1;
   unsigned bit6 : 1;
   unsigned bit5 : 1;
   unsigned bit4 : 1;
   unsigned bit3 : 1;
   unsigned bit2 : 1;
   unsigned bit1 : 1;
   unsigned bit0 : 1;
}bits

So brauchst du ein Byte und kannst es mit bis zu 100% ausnutzen.

[Stefan M. (Gast)]

@Stephan: Oh, ich hab da was überlesen. Entschuldige bitte. Fühlst Du 
Dich etwa auf den Schlips getreten? Dein Problem. Deinen Kommentar 
hättest Du Dir auch sparen können.

[Karl H. (kbuchegg)]

> eigetnlich unbedingt um Platz zu sparen. weiss
> da jemand eine Abhilfe,

Wenns ums Platz sparen geht, hilft dir weder ein
bool noch ein unsigned char. In beiden Fällen verbraucht
jeder einzelne boolean nach wie vor 1 Byte.

Platz sparen (im SRAM) kann man eigentlich nurnoch, indem
mehrere Boolean gemeinsam in ein Byte gequetscht werden,
man also die nicht benutzten Bits eines Bytes für andere
Bollean weiterbenutzt. Allerdings erkauft man sich diesen
Platzgewinn mit erhöhtem Codeaufwand und auch mit erhöhter
Laufzeit.

unsigned char Flags;

#define FLAG1     0x01
#define FLAG2     0x02
#define FLAG3     0x04

#define IS_TRUE(x)  (( Flags & (x) ) == x )
#define IS_FALSE(x) (( Flags & (x) ) == 0 )

#define SET_TRUE(x)  ( Flags |= (x) )
#define SET_FALSE(x) ( Flags &= ~(x) )


int main()
{
  if( IS_TRUE( FLAG1 ) ) {
    SET_TRUE( FLAG2 );
    SET_FALSE( FLAG1 );
  }
}

Man kann sich selbst alternativ das Leben einfacher machen, indem
man eine struct definiert

struct {
  unsigned char Flag1 : 1;   // 1 Bit eines unsigned char als Variable
  unsigned char Flag2 : 1;   // noch 1 Bit derselben unsigned char
} Flags;

int main()
{
  Flags.Flag1 = 1;

  if( Flags.Flag1 ) {
    Flags.Flag2 = 0;
    Flags.Flag1 = 1;
  }
}

Wie gesagt: die Schreibweise wird einfacher. Aber im Hintergrund
passiert dasselbe wie in der ersten Lösung, nur das diesmal sich
der Compiler slbsttätig um die richtige Maskierung kümmert.

[Oliver (Gast)]

>bräuchte die aber eigetnlich unbedingt um Platz zu sparen.

Da frage ich doch mal zurück: Warum? Was für einen Minicontroller 
verwendest du, daß da ca. 10 byte mehr so große Probleme machen?

Oliver

[Michael Wilhelm (Gast)]

@ Karl Heinz,

wird bei einem Bitfeld nicht vom Compiler gleich ein int angelegt? Meine 
ich mal gelesen zu haben.

MW

[Johannes M. (johnny-m)]

Michael Wilhelm wrote:
> wird bei einem Bitfeld nicht vom Compiler gleich ein int angelegt? Meine
> ich mal gelesen zu haben.
Ich meine, mich erinnern zu können, das mit dem WINAVR mal ausprobiert 
und dabei festgestellt zu haben, dass zumindest besagter Compiler 
Bitfelder tatsächlich in Vielfachen von 8 Bit ablegen kann.

[Karl H. (kbuchegg)]

Michael Wilhelm wrote:
> @ Karl Heinz,
>
> wird bei einem Bitfeld nicht vom Compiler gleich ein int angelegt? Meine
> ich mal gelesen zu haben.

Da bin ich mir auch immer unsicher. Ich hab auch schon gelesen
dass der Datentyp des Members immer int sein muss. Allerdings
scheinen sich hier die Aussagen etwas zu widersprechen und
C-Standard hab ich keinen da um in der 'letzten Instanz' nach-
zuschlagen.

[Rolf Magnus (Gast)]

> Da frage ich doch mal zurück: Warum? Was für einen Minicontroller
> verwendest du, daß da ca. 10 byte mehr so große Probleme machen?

Die Antwort darauf weiß ich zwar nicht, aber die kleinsten von gcc 
unterstützten AVRs haben 64 Bytes RAM, und da muß ja auch noch der Stack 
rein.
Außerdem könnte man auch mal größere Arrays brauchen, in denen jedes 
Element mehrere solcher booleschen Werte enthält.

[Andy Y. (merlin129)]

Ich weiß ist alt, aber vielleicht juckt es jemand:

typedef enum {
    false = 0,
    true
} t_bool;

Das setzt allerdings voraus das true == 1 ist und nicht true =< 1...

[Rufus Τ. F. (rufus)]

Andreas Pantle schrieb:
> Das setzt allerdings voraus das true == 1 ist und nicht true =< 1...

Und deswegen ist das Unfug. In C ist alles, was nicht 0 ist, "true".

Warum Du das jetzt nach nur sieben Jahren noch rauskramen musstest, 
wirst auch nur Du wissen.