🚀 go-pugleaf

Hi,
Dmitrij Sverdlov (sverdlov@informatik.hu-berlin.de) wrote:
: Ich schreibe gerade eine Klasse für Bitfelder und komme nicht weiter.
: Bisher habe ich folgendes geschafft:

[groesstenteils geloescht]

: char bitfield::operator[] (unsigned bitNr)
: {
:  return ( bitarray [bitNr/8] ) & ( 1 << bitNr%8 ) ;
: }

: Mit der Überladung von [] habe ich nun Ausdrücke der Form

: bitfield Bitfield(100);
: ...
: if ( Bitfield[45] )  { ... } 
: ...

: ermöglicht, also das Lesen der Bits. Wie kann ich aber die Bits
: schreiben, also z.B.  Bitfield[67] = 1;  ?

Mach es doch einfach so, wie es bei der Standard-Klasse 'bitset'
gemacht wird:  Ueber eine Proxy-Klasse, die eine Referenz auf ein Bit
darstellt ('bitset' ist zugegebenermassen relativ unbekannt; in
Plauger's Buch wird sie als 'bits' dokumentiert):

  template <size_t N> class bitset
  {
    //...
  public:
    class reference
    {
      friend class bitset<N>;
      //...
    public:
      reference const &operator= (reference const &newVal);
      reference const &operator= (bool newVal);
      operator bool() const;
    };

    reference operator[] (unsigned int bitIdx);
    bool      operator[] (unsigned int bitIdx) const;
  };

Die Implementation der relevanten Funktionen ist relativ einfach: Die
'reference' wird mit einer Referenz auf den entsprechenden 'char' und
der Bitnummer (oder der entsprechenden Maske) konstruiert. Die
Operatoren von 'reference' lassen sich dann einfach implementieren.
--
dietmar.kuehl@uni-konstanz.de
http://www.informatik.uni-konstanz.de/~kuehl/
I am a realistic optimist - that's why I appear to be slightly pessimistic

Dmitrij Sverdlov writes:
>  delete bitarray;

Das muß delete [] bitarray; heißen

> char bitfield::operator[] (unsigned bitNr)

Hier solltest Du besser ein bool zurückgeben.

> ermöglicht, also das Lesen der Bits. Wie kann ich aber die Bits
> schreiben, also z.B.  Bitfield[67] = 1;  ?

Aaah, das ist ein Problem, da es ja in C++ und damit Deiner (zugegeben 
platzsparenden) Implementation keinen Pointer auf ein Bit geben kann.
Fällt mir jetzt spontan nix dazu ein außer für jedes Bit ein char zu
verwenden oder mal in die libg++ reinzuschauen, da gibt es mehrere
Klassen für.


ralf

Dmitrij Sverdlov (sverdlov@informatik.hu-berlin.de) wrote:
> ermöglicht, also das Lesen der Bits. Wie kann ich aber die Bits
> schreiben, also z.B.  Bitfield[67] = 1;  ?

Der uebliche Weg ist, eine Referenz zurueckzuliefern. Das funktioniert aber
hier aus offensichtlichen Gruenden nicht. Was Du statt dessen machen kannst
ist das Ueberladen der Operatoren "+" und "+=".

Gruss


        Uz

-- 
Ullrich von Bassewitz                              uz@ibb.schwaben.com

Ralf W. Stephan schrieb in <1996Apr9.153753.1392@ark.franken.de> folgendes:

> Dmitrij Sverdlov writes:
> >  delete bitarray;
> 
> Das muß delete [] bitarray; heißen
> 
> > char bitfield::operator[] (unsigned bitNr)
> 
> Hier solltest Du besser ein bool zurückgeben.
> 
> > ermöglicht, also das Lesen der Bits. Wie kann ich aber die Bits
> > schreiben, also z.B.  Bitfield[67] = 1;  ?
> 
> Aaah, das ist ein Problem, da es ja in C++ und damit Deiner (zugegeben
> platzsparenden) Implementation keinen Pointer auf ein Bit geben kann.
> Fällt mir jetzt spontan nix dazu ein außer für jedes Bit ein char zu
> verwenden oder mal in die libg++ reinzuschauen, da gibt es mehrere
> Klassen für.
> 
> 
> ralf

Eine andere Möglichkeit wäre, daß der operator[] ein Objekt zurückgibt, das
sich merkt welches Bit angesprochen wurde und das einen Zuweisungsoperator
besitzt.

Stellt sich nur die Frage, ob man für eine "natürlichere" Syntax sowas auf
sich nehmen will. (Was ist z.B. mit der Lebensdauer von Array bzw.
Hilfsobjekt etc.?)

Bis demnächst...
	Walter Dörwald

Hi,
Walter Doerwald (walter@data.franken.de) wrote:
: Eine andere Möglichkeit wäre, daß der operator[] ein Objekt zurückgibt, das
: sich merkt welches Bit angesprochen wurde und das einen Zuweisungsoperator
: besitzt.

Siehe meinen vorherigen Artikel in diesem Thread bzw. direkt die
Definition der Klasse 'bitset' im DWP.

: Stellt sich nur die Frage, ob man für eine "natürlichere" Syntax sowas auf
: sich nehmen will. (Was ist z.B. mit der Lebensdauer von Array bzw.
: Hilfsobjekt etc.?)

Nun, es gibt eigentlich keine Probleme: Es ist leicht zu implementieren
und es kostet auch nicht so furchtbar viel Laufzeit. Indem man die
Konstruktoren der entsprechenden Klasse alle 'private' macht (und die
Bit-Klasse zu einem Freund), laesst sich auch das Problem mit der
Lebensdauer [fast] vollstaendig beseitigen:  Die einzige Moeglichkeit,
dass ein Hilfobjekt ein Objekt in einem zerstoerten Array referenziert
ist, eine Referenz auf das Hilfsobjekt, das von 'operator[]()'
zurueckgeliefert wird, zu nehmen und dann das Array zu zerstoeren. Ein
etwas merkwuerdiges Vorgehen...
--
dietmar.kuehl@uni-konstanz.de
http://www.informatik.uni-konstanz.de/~kuehl/
I am a realistic optimist - that's why I appear to be slightly pessimistic