Zapisywanie pojedynczych bitów.

Czy da się zapisać do pliku mniej niż 1 bajt? Coś mi się zdaje, że nie, ale wolę spytać.

Mam taki ciąg: 10101010;
Jak go zapisać do zmiennej char?
Zrobiłem tak:
char a = 0x55;
Chodzi mi jednak o widoczność tych 0 i 1 w kodzie.

Nie da się zapisać mniej niż bajt, i nie ma natywnego sposobu na zapis liczby binarnej. Ale co to za problem, hex przy odpowiednim obyciu rozkładasz na bity automatycznie.

nie da się, api odpowiedzialne za zapis/odczyt określają wielkości transferu danych w bajtach. możesz sobie wiec zapisać w pierwszym bajcie/słowie pliku maskę bitową dla ostatniego bajtu, albo ilość zapisanych bitów

można tak:
a = 1 << 7 | 1 << 5 | 1 << 3 | 1 << 1 - wtedy od razu widać na których miejscach są jedynki.

Nie da się :-P A ja mówię, że się da (w pewnym sensie). Przypomniało mi się, że mamy coś takiego jak unie :)

#include <iostream>
#include <fstream>

using namespace std;

int main()
{
	ofstream plik("plik.txt", ios_base::binary);

	struct zx
	{
		unsigned int a : 1;
		unsigned int b : 1;
		unsigned int c : 1;
		unsigned int d : 1;
		unsigned int e : 1;
		unsigned int f : 1;
		unsigned int g : 1;
		unsigned int h : 1;
	};

	union
	{
		zx zxc;
		char znak;
	};

	zxc.a = 0;
	zxc.b = 1;
	zxc.c = 1;
	zxc.d = 0;
	zxc.e = 1;
	zxc.f = 1;
	zxc.g = 1;
	zxc.h = 0;

	for(int i = 0; i <7; i++)
		plik.write(&znak, 1);

	plik.close();

	return 0;
}

Zapisujesz 7 razy ten sam bajt. O to ci chodziło?

Chodziło mi o ten kawałek:

        struct zx
        {
                unsigned int a : 1;
                unsigned int b : 1;
                unsigned int c : 1;
                unsigned int d : 1;
                unsigned int e : 1;
                unsigned int f : 1;
                unsigned int g : 1;
                unsigned int h : 1;
        };

        union
        {
                zx zxc;
                char znak;
        };

        zxc.a = 0;
        zxc.b = 1;
        zxc.c = 1;
        zxc.d = 0;
        zxc.e = 1;
        zxc.f = 1;
        zxc.g = 1;
        zxc.h = 0;

Jeżeli sobie ustawię:

        struct zx
        {
                unsigned int a : 1;
                unsigned int b : 1;
                unsigned int c : 1;
                unsigned int d : 1;
                unsigned int e : 1;
                unsigned int f : 1;
                unsigned int g : 1;
                unsigned int h : 1;
        };

        union
        {
                zx zxc;
                char znak;
        };

        znak = 0;

        zxc.g = 1;

To od lewej 2 bit będzie jedynką, a przy dodaniu odpowiedniej funkcji, która przerabiałaby ciąg 10101010 byłoby ok, ale mniejsza o funkcję. Może nie sprecyzowałem, ale nie chciałem się babrać w hex'ie.
To też może być:

można tak:
a = 1 << 7 | 1 << 5 | 1 << 3 | 1 << 1 - wtedy od razu widać na których miejscach są jedynki.

[code]
for(int i = 0; i <7; i++)
plik.write(&znak, 1);
[/code]

i to zapisze 7 bitów na HDD ?;-)

bajtów

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

      unsigned char wartosc;
   };
};

int main()
{
   Bajt bajt = { 1, 0, 1, 1, 0, 0, 0, 1 };
   ofstream plik("dane.bin", ios::out | ios::binary);
   plik.put(bajt.wartosc); //zapisze do pliku "dane.bin" jeden bajt o kodzie binarnym 10110001b
}

Jednak osobiście użyłbym przesunięcia bitowego, czyli to co rnd proponował:

int main()
{
   unsigned char bajt =
      1 << 7 |
      0 << 6 | //można pominąć
      1 << 5 |
      1 << 4 |
      0 << 3 | //można pominąć
      0 << 2 | //można pominąć
      0 << 1 | //można pominąć
      1 << 0;
   ofstream plik("dane.bin", ios::out | ios::binary);
   plik.put(bajt); //zapisze do pliku "dane.bin" jeden bajt o kodzie binarnym 10110001b
}