kontener na bity

#include <iostream>
#include <cstdio>
#include <string>

using namespace std;

class TabBit
{
  typedef unsigned long long slowo; // komorka w tablicy
  static const int rozmiarSlowa = sizeof(slowo); // rozmiar slowa w bitach
  friend istream & operator >> (istream &we, TabBit &tb);
  friend ostream & operator << (ostream &wy, const TabBit &tb);
  class Ref; // klasa pomocnicza dla operatora indeksowania
  class Zakres {}; // klasa wyjatku
  protected:
   int dl; // liczba bitów
   slowo *tab; // tablica bitów
  public:
   void operator << (TabBit b);
   explicit TabBit (int rozm);
   TabBit (const TabBit &tb);
   TabBit & operator = (const TabBit &tb);
   ~TabBit ();
  //private:
   bool czytaj (int i) const;
   bool pisz (int i, bool b);
  public:
   bool operator[] (int i) const;
   Ref operator[] (int i);
   inline int rozmiar () const { return dl; }
};



class TabBit::Ref {
        TabBit* ptr;
        int indeks;
public:
        Ref(TabBit* p, int i) : ptr(p), indeks(i) {}
        operator bool() const {
                return ptr->czytaj(indeks);
        }
        bool operator =(bool b) {
                ptr->pisz(indeks, b);
        }
        bool operator =(Ref& ref) {
                return ref;
        }
};


TabBit :: TabBit( int rozm )
{
    dl = rozm;
    rozm=(rozm/8)+1;
    tab = new slowo[rozm];
    while( --rozm >= 0 ) tab[rozm] = 0;
}

TabBit :: ~TabBit()
{ delete []tab; }


bool TabBit :: czytaj( int i ) const
{ 
	//	if i >= dl zgłoś wyjątek
	int iSlowo = i / rozmiarSlowa;
	int iBit = i % rozmiarSlowa;
	slowo mask = 1;
	mask = mask << iBit ;
	return (bool)((tab[iSlowo] & mask) >> iBit);
}

bool TabBit :: pisz( int i, bool b )
{
	//	if i >= dl zgłoś wyjątek
	int iSlowo = i / rozmiarSlowa;
	int iBit = i % rozmiarSlowa;
	slowo mask = 1;
	if( b )
 		tab[iSlowo] = tab[iSlowo] | (mask << iBit);
	else { mask = ~mask;
 		tab[iSlowo] = tab[iSlowo] & (mask << iBit); }
}


ostream & operator << (ostream &wy, const TabBit &tb)
{
 for(int i=0;i<tb.dl;i++)
 {
  cout << tb.czytaj(i);
 }
 return wy;
}

istream & operator >> (istream &we, TabBit &tb)
{
 string data;
 we >> data;
 cout << data << endl;
 int i=0;
 while(i<data.length())
 {
    switch(data[i]) {
       case '1': tb.pisz(i,true); break;
       default : tb.pisz(i,false); break;
    }
    cout << tb << endl;
  i++;
 }
 return we;
}


int main()
{
int  tab[1];
int n=5;
TabBit t(n);// tablica 72 bitow
t.pisz(0,false);
t.pisz(3,true);
cout << "Podaj dane do wczytania" << endl;
cin>>t;
cout << t << endl;
//t[0] = 1; // ustawienie bitu 0-ego bitu na 1
cin.ignore();
getchar();
return 0;
}

Program ma działać jako kontener na bity tylko że jak mu podaję 111011 to zwraca mi 000011 (zeruje jedynki które poprzedzają zero) mógłby mi ktoś powiedzieć gdzie jest błąd (pewnie dociążenie operatora >> albo nieprawidłowa funkcja pisz) ?

static const int rozmiarSlowa = sizeof(slowo); // rozmiar slowa w bitach

albo to jest w BAJTACH albo powinno być sizeof(slowo)*8;.
Na razie tyle wypatrzyłem (na szybkiego).

rozumiem, że nie możesz użyć vector<bool> ani bitset<ile bitów>?

Tudzież http://www.sgi.com/tech/stl/bit_vector.html

w TabBit :: TabBit( int rozm )

rezerwujesz za dużo (w końcu slow nie jest typu char ale long long int), źle obliczasz rozmiar!

bool TabBit :: czytaj( int i ) const

tu widać, że powinno być

static const int rozmiarSlowa = sizeof(slowo)*8;

istream & operator >> (istream &we, TabBit &tb)

nie podoba mi się zastosowanie switch-a. Powinno być case '1' i case '2' a w default obsługa błędu.

int main() 
...
TabBit t(n);// tablica 72 bitów

Popatrz do swojego konstruktora! Coś ci się pomieszało.

Tu nie chodzi o komentarze. Tylko o to że źle działa zapisywanie nie wiem jak zmienić maskę w funkcji pisz żeby to ładnie działało...

To jest poprawna funkcja pisz:

bool TabBit :: pisz( int i, bool b )
{
	//	if i >= dl zgłoś wyjątek
	int iSlowo = i / rozmiarSlowa;
	int iBit = i % rozmiarSlowa;
	slowo mask = 1<<iBit;
	if( b )
 		tab[iSlowo] = tab[iSlowo] | mask;
	else {
 		tab[iSlowo] = tab[iSlowo] & ~mask; }
}