Разбить файл на биты

#include <iostream>
#include <bitset>
 
using namespace std;
 
typedef unsigned char byte;
int main()
{
    cout << "Enter a byte [0..255]" << endl;
    unsigned int buffer;
    cin >> buffer; cin.get();
    byte myByte = static_cast<byte>(buffer);
    bitset<8> myBits(myByte);
    cout << "Bits: ";
    for (int i = 0, N = myBits.size(); i < N; ++i)
        cout << myBits[N - i - 1];
    cin.get();
}

unsigned char myByte;
bitset<8> myBits(myByte);

byte myByte = ...;
bitset<8> myBits(myByte);
for (i = 0; i < N; i++)
  cout << myBits[N - i - 1];

/////////////////////////////////////////////////////////////////////////////////////////
//Каким образом осуществить разбиение файла на биты, а потом ещё его желательно будет и собрать. 
/////////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <bitset>
#include <climits>
#include <cstdlib>
#include <ctime>
#include <fstream>
#include <iostream>
#include <limits>
#include <sstream>
#include <string>
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::string  T_str;
/////////////////////////////////////////////////////////////////////////////////////////
void  bytesfile_to_bitsfile
    (
        const T_str&    bytes_filename,
        const T_str&    bits_filename
    )
{
    std::ifstream   ibytes_file     ( bytes_filename    .c_str(),   std::ios::binary    );
    std::ofstream   obits_file      ( bits_filename     .c_str()                        );
 
    char  byte_symb;
    while( ibytes_file.get(byte_symb) )
    {
        obits_file  <<  std::bitset<CHAR_BIT>(byte_symb).to_string();
    }    
}
/////////////////////////////////////////////////////////////////////////////////////////
void  bitsfile_to_bytesfile
    (
        const T_str&    bits_filename,
        const T_str&    bytes_filename        
    )
{
    std::ifstream   ibits_file      ( bits_filename     .c_str(),   std::ios::binary    );
    std::ofstream   obytes_file     ( bytes_filename    .c_str()                        );
 
    char    bit_symb;
    T_str   byte_str;
    while( ibits_file.get(bit_symb) )
    {
        byte_str += bit_symb;
        if( byte_str.size() == CHAR_BIT )
        {
            char  byte_symb     =   char( std::bitset<CHAR_BIT>(byte_str).to_ulong() );
            obytes_file         <<  byte_symb;
            byte_str.clear();
        }
    }
}
/////////////////////////////////////////////////////////////////////////////////////////
bool  files_compare
    (
        const T_str&    L,
        const T_str&    R
    )
{
    std::ifstream   L_file      ( L.c_str(),    std::ios::binary    );
    std::ifstream   R_file      ( R.c_str(),    std::ios::binary    );
 
    std::ostringstream  L_sout;
    L_sout  <<  L_file.rdbuf();
 
    std::ostringstream  R_sout;
    R_sout  <<  R_file.rdbuf();
 
    return  L_sout.str()    ==  R_sout.str();
}
/////////////////////////////////////////////////////////////////////////////////////////
void  random_fill_file
    ( 
        const T_str&    filename,
        int             symbols_total
    )
{
    std::ofstream   ofile( filename.c_str(),     std::ios::binary    );
    const char  char_min    =   std::numeric_limits<char>::min();
    const char  char_max    =   std::numeric_limits<char>::max();
    
    for(int  i = 0; i < symbols_total; ++i)
    {
        char    rand_symb   =   rand() % (char_max - char_min + 1) + char_min;
        
        if( !iscntrl(rand_symb) )
        {
            ofile.put(rand_symb);
        } 
    }
}
///////////////////////////////////////////////////////////////////////////////////////// 
void  print_file( const T_str&  filename )
{
    std::ifstream   ifile( filename.c_str() );
 
    std::cout   <<  std::endl
                <<  std::endl
                <<  std::endl
                <<  filename                
                <<  ":"
                <<  std::endl
                <<  std::endl
                <<  ifile.rdbuf()
                <<  std::endl
                <<  std::endl;
}
/////////////////////////////////////////////////////////////////////////////////////////
int main()
{    
    srand(unsigned(time(0)));
 
    const T_str     bytes_start_filename    =   "bytes_start.txt";
    const T_str     bits_filename           =   "bits.txt";
    const T_str     bytes_finish_filename   =   "bytes_finish.txt";
 
    const int       BYTES_START_FILE_SIZE   =   100;
    random_fill_file
        (
            bytes_start_filename,
            BYTES_START_FILE_SIZE
        );
    
    bytesfile_to_bitsfile
        (
            bytes_start_filename,
            bits_filename
        );
 
    bitsfile_to_bytesfile
        (
            bits_filename,
            bytes_finish_filename
        );
 
    std::cout   <<  (
                        files_compare
                            (
                                bytes_start_filename,
                                bytes_finish_filename
                            )
                            ? bytes_start_filename + " == " + bytes_finish_filename
                            : bytes_start_filename + " != " + bytes_finish_filename
                    )
 
                <<  std::endl;
 
    print_file( bytes_start_filename    );
    print_file( bits_filename           );
    print_file( bytes_finish_filename   );
}