float p= 3.14;
char *pf= reinterpret_cast<char*>(&p);

Die einzelnen Bits sollen in einem vector<bool> gespeichert werden.

Ehrlich gesagt weiß ich nicht wie ein aktueller Computer eine Kommazahl speichert, aber ich habe in meinem ersten Semester mehrere Methoden kennengelernt wie das zu bewerkstelligen ist.
Eine für Festkommadarstellung, und ein paar für Gleitkommadarstellung.
Glaube der IEEE Standard mit der benötigten Genauigkeit wird genutzt (float = 32bit). Da hast du dann ein Bit fürs Vorzeichen, 8 für den Exponent und 23 für die Mantisse...

Alles ungetestet.

#include <iostream>
#include <vector>
#include <iterator>
#include <algorithm>

template<class Inserter, class Type>
void push_binary(Type const& value, Inserter insert)
{
    for(int byte = 0; byte < sizeof(Type); ++byte) {
        for(int bit = 0; bit < 8; ++bit) {
            insert = (reinterpret_cast<const unsigned char*>(&value)[byte]
                     & (1 << bit)) > 0 ? 1 : 0;
        }
    }
}

int main()
{
    using namespace std;

    vector<bool> vec;
    vec.reserve(sizeof(float) * 8);
    push_binary(3.14f, back_inserter<vector<bool> >(vec));
    copy(vec.begin(), vec.end(), ostream_iterator<bool>(cout, "\n"));

	return 0;
}

http://www.crystalclearsoftware.com/cgi-bin/boost_wiki/wiki.pl?CPPTM_Answers_-_Exercise_3-0

Die Überprüfung mit dem BOOST_STATIC_ASSERT habe ich dort heraus übernommen.

#include <cstdlib>
#include <iostream>
#include <boost/static_assert.hpp>

using namespace std;

template <unsigned int n> struct binary
{
  static const unsigned int d = n % 10;
  BOOST_STATIC_ASSERT(d == 0 || d == 1);
  static const unsigned int value = d + (binary<n/10>::value * 2);
};

template <> struct binary<0>
{
  static const unsigned int value = 0;
};

int main()
{
  cout << binary<11001>::value << endl;
  cout << binary<110111>::value << endl;
  cout << binary<1111011>::value << endl;

  /**
   * Ausgabe: 25 55 123
   */

  return EXIT_SUCCESS;
}