Ребята есть ли метод vector <bool> записать в бинарный файл?

    vector<scan_info>::iterator in=mass.begin();
    while(in!=mass.end())
    {
        fout.write((char *)&in,sizeof(scan_info));
        ++in;
    }

#include <vector>
#include <fstream>
#include <iostream>
#include <algorithm>
using namespace std;
 
int main()
{
    vector<bool> vec;
    vec.push_back(true);
    vec.push_back(false);
    vec.push_back(true);
    vec.push_back(true);
 
    //vec.data();
    for(size_t i = 0; i < vec.size(); i++)
    {
        if(vec[i])
            cout<<"true"<<endl;
        else
            cout<<"false"<<endl;
    }
 
    ofstream ofs("data.txt");
    copy(vec.begin(), vec.end(), ostream_iterator<bool>(ofs, " "));
    ofs.close();
    
    return 0;
}

template <class Allocator> class vector<bool, Allocator> {
public:
   // types:
   typedef bool const_reference;
   typedef implementation-defined iterator; // see 23.2
   typedef implementation-defined const_iterator; // see 23.2
   typedef implementation-defined size_type; // see 23.2
   typedef implementation-defined difference_type;// see 23.2
   typedef bool value_type;
   typedef Allocator allocator_type;
   typedef implementation-defined pointer;
   typedef implementation-defined const_pointer;
   typedef std::reverse_iterator<iterator> reverse_iterator;
   typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
   // bit reference:
   class reference {
      friend class vector;
      reference();
   public:
      ~reference();
      operator bool() const;
      reference& operator=(const bool x);
      reference& operator=(const reference& x);
      void flip();
       // flips the bit
   };
   // construct/copy/destroy:
   explicit vector(const Allocator& = Allocator());
   explicit vector(size_type n, const bool& value = bool(), const Allocator& = Allocator());
   template <class InputIterator>
   vector(InputIterator first, InputIterator last, const Allocator& = Allocator());
   vector(const vector<bool,Allocator>& x);
   vector(vector<bool,Allocator>&& x);
   vector(const vector&, const Allocator&);
   vector(vector&&, const Allocator&);
   vector(initializer_list<bool>, const Allocator& = Allocator()));
   ~vector();
   vector<bool,Allocator>& operator=(const vector<bool,Allocator>& x);
   vector<bool,Allocator>& operator=(vector<bool,Allocator>&& x);
   vector operator=(initializer_list<bool>);
   template <class InputIterator>
   void assign(InputIterator first, InputIterator last);
   void assign(size_type n, const bool& t);
   void assign(initializer_list<bool>;
   allocator_type get_allocator() const;
   // iterators:
   iterator begin();
   const_iterator begin() const;
   iterator end();
   const_iterator end() const;
   reverse_iterator rbegin();
   const_reverse_iterator rbegin() const;
   reverse_iterator rend();
   const_reverse_iterator rend() const;
   const_iterator cbegin() const;
   const_iterator cend() const;
   const_reverse_iterator crbegin() const;
   const_reverse_iterator crend() const;
   // capacity:
   size_type size() const;
   size_type max_size() const;
   void resize(size_type sz, bool c = false);
   size_type capacity() const;
   bool empty() const;
   void reserve(size_type n);
   void shrink_to_fit();
   // element access:
   reference operator[](size_type n);
   const_reference operator[](size_type n) const;
   const_reference at(size_type n) const;
   reference at(size_type n);
   reference front();
   const_reference front() const;
   reference back();
   const_reference back() const;
   // modifiers:
   void push_back(const bool& x);
   void pop_back();
   iterator insert(const_iterator position, const bool& x);
   iterator insert (const_iterator position, size_type n, const bool& x);
   template <class InputIterator>
   iterator insert(const_iterator position,InputIterator first, InputIterator last);
   iterator insert(const_iterator position, initializer_list<bool> il);
   iterator erase(const_iterator position);
   iterator erase(const_iterator first, const_iterator last);
   void swap(vector<bool,Allocator>&);
   static void swap(reference x, reference y);
   void flip();
   // flips all bits
   void clear();
};