¿Algo así?

#include <iostream>
 
class A
{
    int a;
    int b;
 
  public:
 
    A( )
      : a( 1 ), b( 2 )
    { }
};
 
void Imprime( void* ptr, size_t size )
{
  char* charPtr = static_cast< char* >( ptr );
 
  while( size-- > 0 )
  {
    char mask = 1;
    do
    {
      std::cout << (*charPtr & mask ? '1' : '0');
    } while( mask <<= 1 );
 
    std::cout << ' ';
    ++charPtr;
  }
}
 
int main()
{
  A a;
 
  Imprime( &a, sizeof( a ) );
}

---

Editado:

Después de pensarlo con un pelín más de tranquilidad... no hace falta pasar el size... basta con usar un template. Eso sí, debidamente especializado para poder manejar tanto punteros como referencias

#include <iostream>
#include <type_traits>
 
class A
{
    int a;
    int b;
 
  public:
 
    A( )
      : a( 1 ), b( 2 )
    { }
};
 
template< typename T >
typename std::enable_if< std::is_pointer< T >::value, void >::type Imprime( T ptr )
{
  std::cout << "Pointer version: ";
  char* charPtr = reinterpret_cast< char* >( ptr );
  size_t size = sizeof( typename std::remove_pointer< T >::type );
  while( size-- > 0 )
  {
    char mask = 1;
    do
    {
      std::cout << (*charPtr & mask ? '1' : '0');
    } while( mask <<= 1 );
 
    std::cout << ' ';
    ++charPtr;
  }
}
 
template< typename T >
typename std::enable_if< !std::is_pointer< T >::value, void >::type Imprime( const T& value )
{
  std::cout << "Reference version: ";
  const char* charPtr = reinterpret_cast< const char* >( &value );
  size_t size = sizeof( T );
  while( size-- > 0 )
  {
    char mask = 1;
    do
    {
      std::cout << (*charPtr & mask ? '1' : '0');
    } while( mask <<= 1 );
 
    std::cout << ' ';
    ++charPtr;
  }
}
 
int main()
{
  A a;
 
  Imprime( &a );
  std::cout << std::endl;
  Imprime( a );
}

Utilizo reinterpret_cast porque detesto los cast a la usanza de C "int valor = (int)X;" y la conversión entre los dos tipos no tiene por qué ser compatible. En este caso, con reinterpret_cast le estoy diciendo al compilador algo del estilo "tranquilo que se lo que me hago, esta conversión es legal aunque no lo parezca".

remove_pointer es un template de type_trait y lo que hace es eliminar el puntero de la declaración del tipo. sizeof( T* ) va a devolver, normalmente, 4, ya que un puntero ocupa 4 bytes, sin embargo yo quiero calcular sizeof( T ). Y para hacer este último cálculo necesito eliminar el puntero de la declaración.

En cuanto al segundo byte, puede ser alineamiento provocado por tu compilador. Piensa que en una arquitectura de 32 bits, el procesador optimiza para que los datos entren en estos 32 bits, que es el tamaño normal con el que trabaja... si tu usas únicamente 24 bits, el compilador puede decidir desperdiciar los otros 8 para que el alineamiento sea perfecto.

Si la arquitectura es de 64 bits, entonces 64 bits es la unidad mínima de datos, luego lo normal es que la memoria consumida por cualquier programa sea múltiplo de 64 bits