• Als Spam markieren
• Beitrag melden

• 
  Diese Gruppe Alles

• Archiv
• RSS-Feeds

• Kontakt
• Hilfe
• Impressum
• Datenschutz

getBit (operator[] lesend), setBit (operator[] schreibend)

Hallo zusammen,

Mir sind die Existenzen von bitset (aus der STL
http://www.cplusplus.com/reference/stl/bitset/ )

und dynamic_bitset (aus boost
http://www.boost.org/doc/libs/1_35_0/libs/dynamic_bitset/dynamic_bitset.h
tml)

bekannt, beide Bitsets bieten den operator[] an:

[stl:] The function returns the value (or a reference) to the bit at
position pos.

[boost:] It provides accesses to the value of individual bits via an
operator[]



Ich produziere mir eine eigene Klasse Bitfield, mit anderen
Funktionalistäten (Wortspiegelungen, etc )

Natürlich habe ich mir zwei Methoden getBit und setBit geschieben,
siehe unten:

Den nur lesenden operator[] z.B. für die Nutzung bei

Bitfield B(5);
B.setbit(4, true);
std::cout << B[4];

habe ich auf meine getBit Methode umgeleitet:

bool  Bitfield::operator[](const size_t& i) const{
if ( i>=theSize.bits) throw(rangeError());
return (getBit(i));
}


Gerne würde ich nun aber auch den schreibenden operator[]
implementieren, allerdings komme ich nicht dahinter wie das gehen soll.

Denn ich würde gerne die Möglichkeit bieten neben
B.setBit(4, true);
auch
B[4] = true;
schreiben zu können.

Es wäre nett, wenn Ihr mir mal wieder auf die Sprünge helfen könnte
t.

Gruß Robert


//////////////

Im folgenden sei
typedef unsigned char byte;
gegeben

sowie die Klassenvariable

byte * theField;


bool Bitfield::getBit(const size_t& bit) const {

if ((bit >= theSize.bits) || (theField == NULL))
throw rangeError();
assert(((bit < theSize.bits) && (this->theField != NULL)));

bool ret = false;

if ((bit < theSize.bits) && (this->theField != NULL)) {

size_t byteNr = bit / BITFIELD_BYTE_BITSIZE;
size_t bitNr = bit % BITFIELD_BYTE_BITSIZE;

byte& theByte = theField[byteNr];

//Verschiebe 1 nach links auf Bitnummer,
// bitweises UND mit dem Byte -> nur Position Bitnummer
// kann mit 1 belegt sein.
// Verschiebe wieder nach rechts um die gleiche Anzahl
// der Bits und vergleiche logisch mit 1 -> entweder ist
// dies der Vergleich von 1 mit 1, oder 0 mit 1
ret = (((theByte & (1 << bitNr)) >> bitNr) == 1);
}
return ret;
}



bool Bitfield::setBit(const size_t& bit, const bool& value) {
bool res = true;

if ((theField == NULL) || (theSize.bits < bit)) {
res = setSize(bit + 1); // vergrößert das Feld
}

if ((theField == NULL) || (!res))
return false;

//Bestimme aus bit -das ist die Bitnummer über das ganze
//Feld gesehen-, die Byte-Nr und die Position in dem Byte
size_t byteNr = bit / BITFIELD_BYTE_BITSIZE;
size_t bitNr = bit % BITFIELD_BYTE_BITSIZE;

byte& theByte = theField[byteNr];

if (value) { //setze Bit
//verschiebe 1 auf Bitnummer,
//dann Zuweisung des bitweisen ODERs

theByte |= (1 << bitNr);

} else { //lösche Bit
//verschiebe 1 auf Bitnummer,
//invertiere das, dann Zuweisung des bitweisen UNDs

theByte &= ~(1 << bitNr);
}
return true;
}

Antworten