✔ Eine 1 Bit Variable ?

[3Cyb3r]

Ist es möglcih sich in c++ einen 1 Bit Variblentyp zu definieren?
Also eine Variable in der zustand 0 oder 1 gespeichert werden kann?
Das einzige was ich kenne sind Bitfelder wo ich statt dem kleinsten Datntyp ein unsigned char ( 8Bit ) das ganze in 1 Byte zusammenfassen kann.
Für alle die es nicht kennen:

struct {
   unsigned bStatus_1:1; // 1 Bit für bStatus_1
   unsigned bStatus_2:1; // 1 Bit für bStatus_2
   unsigned bNochNBit:1; // Und hier noch mal ein Bit
   unsigned b2Bits:2;    // Dieses Feld ist 2 Bits breit
   // All das hat in einer einzigen Byte-Variable Platz.
   // die 3 verbleibenden Bits bleiben ungenutzt
} x;

EDITL: Also Frage zu den Bitfeldern:
Das ganze geht nur in eienr Struktur oder täusche ich mich da?
kann ich auch eine Status Array erzeugen?

MFG

 

[XxbambamxX]

Der Datentyp bool kann nur 1 bzw 0 speichern.
Aber soviel ich weiss wird der nicht in einem bit untergebreacht da es zulange dauern würde ein einzelnes Bit anzusprechen.
Was du mit Status Array meinst weiss ich nicht allerdings verhält sich bool meines Wissens genau gleich wie alle anderen Datentypen
d.h ein normales Array lässt sich damit problemlos erzeugen

mfg

 

[3Cyb3r]

Es geht mit um Speicherplatz sparen! (Mikrocontroller Programmieren) Ein Boolarray ist viel zu groß!
mit Statusarray meinte ich in einem Bitfeld dann ein Array:
also z.B. unsigned bStatus[4]:1, keihne Ahnung wie die Syntax ist^^

 

[3Cyb3r]

Der Datentyp bool kann nur 1 bzw 0 speichern.
Aber soviel ich weiss wird der nicht in einem bit untergebreacht da es zulange dauern würde ein einzelnes Bit anzusprechen.
Was du mit Status Array meinst weiss ich nicht allerdings verhält sich bool meines Wissens genau gleich wie alle anderen Datentypen
d.h ein normales Array lässt sich damit problemlos erzeugen

mfg

Ach nur mal so ne Frage wieso antwortest du mir wenn du keine Ahnung hast?
Als ob ich dumm wäre und nicht programmieren könnte.

 

[3Cyb3r]

Ok einscehinend geht es nicht kleiner als Bitfelder.
Somit ist das ganze hier auch erledigt.

 

[Cromon]

Ja, kleiner als 1 Byte geht nicht, sagt der Standard:

The fundamental storage unit in the C++ memory model is the byte. A byte is at least large enough to contain any
member of the basic execution character set and is composed of a contiguous sequence of bits, the number of which
is implementation-defined. The least significant bit is called the low-order bit; the most significant bit is called the
high-order bit. The memory available to a C++ program consists of one or more sequences of contiguous bytes. Every
byte has a unique address.

 

[Jennesta]

Wenn du wirklich genau 1bit benutzen willst fällt mir nur noch gezieltes Bit setzen in größeren Datentypen ein.
Ob dies dann deinem Zweck entspricht und überhaupt sinnvoll ist, zumal du auch immer feste Längen besitzt, weiß ich nicht - kommt halt auf dein Problem an.
Jedoch würde ich zum BoolArray tendieren.
Grüße

 

[Enumerator]

Hi!

Wenn Du die Länge des "Status-Arrays" kennst und auch die Daten des Zielsystems (CHAR_BIT, sizeof(...) etc.), kannst Du unter Umständen auch mit einem Array von passendem unsigned-Datentyp arbeiten.
Ich stand mal vor einer ähnlichen Aufgabe: ein 32-Bit Zielsystem mit CHAR_BIT = 8; benötigt wurde ein Feld von 256 Bit-werten.
Unten ein Code-Schnipsel mit dem ich vorher 'rumgespielt hatte, vielleicht hilft's Dir ja weiter --

#include <assert.h>     /* assert() */
#include <limits.h>     /* CHAR_BIT */
#include <stdint.h>     /* uint64_t */
#include <stdio.h>      /* fprintf(), putc(), FILE, stdout */
#include <stdlib.h>     /* EXIT_SUCCESS */
#include <string.h>     /* memset() */

#define FIELD_SIZE      256
#define FIELD_CHUNKS    4

typedef uint64_t        field_chunk_t;
typedef field_chunk_t   field_t[FIELD_CHUNKS];

#define FIELD_CHUNK_MIN 1ULL
#define FIELD_CHUNK_MAX \
   (FIELD_CHUNK_MIN << (CHAR_BIT * sizeof(field_chunk_t) -1U))

int
print_field(field_t, FILE*);

void
left_shift(field_t);

inline void
set_flag(field_t field, unsigned n)
{
    assert(FIELD_SIZE > n);
    field[n / (FIELD_SIZE / FIELD_CHUNKS)] |=
        FIELD_CHUNK_MAX >> n % (FIELD_SIZE / FIELD_CHUNKS);
}

inline void
unset_flag(field_t field, unsigned n)
{
    assert(FIELD_SIZE > n);
    field[n / (FIELD_SIZE / FIELD_CHUNKS)] &=
        ~(FIELD_CHUNK_MAX >> n % (FIELD_SIZE / FIELD_CHUNKS));
}

int
main(void)
{
    field_t field;
    /* Prüfen ob die Konstruktion Sinn ergibt... */
    assert(FIELD_SIZE == FIELD_CHUNKS * CHAR_BIT * sizeof(field_chunk_t));
    memset((void*) field, 0, sizeof(field));
    set_flag(field, 9U);
    set_flag(field, 19U);
    set_flag(field, 29U);
    set_flag(field, 39U);
    set_flag(field, 49U);
    set_flag(field, 59U);
    set_flag(field, 69U);
    set_flag(field, 79U);
    set_flag(field, 89U);
    set_flag(field, 255U);
    print_field(field, stdout);
    left_shift(field);
    unset_flag(field, 68U);
    unset_flag(field, 100U);
    print_field(field, stdout);
    return EXIT_SUCCESS;
}

void
left_shift(field_t field)
{
    unsigned i;
    for(i = 0; FIELD_CHUNKS != i; ++i)
      {
        if(0 != i && field[i] & FIELD_CHUNK_MAX)
          field[i-1] |= FIELD_CHUNK_MIN;
        field[i] <<= 1;
      }
}

int
print_field(field_t field, FILE *stream)
{
    unsigned i;
    field_chunk_t j;
    int retval;
    for(i = 0, retval = 0; FIELD_CHUNKS != i; ++i)
      {
        for(j = FIELD_CHUNK_MAX; 0 != j; j >>= 1)
          retval += putc(field[i] & j? '1': '0', stream);
        fprintf(stream, " %llu\n", field[i]);
        /* putc('\n', stream); */
      }
    putc('\n', stream);
    return retval;
}

Das Prinzip sollte übertragbar sein - auf so ziemlich alle Vielfache von CHAR_BIT die gleichzeitig restlos durch sizeof(irgendein-unsigned-integer-typ) teilbar sind...

Gruß
Enum