/*
  binary class manipulator
 
  Print values or strings as binary
    by Kimberly Hamrick
*/
#include <iostream> // for C++ I/O
#include <string>   // for C++ strings
 
using namespace std;
 
namespace hamrick {
  template <typename T>
  class binary {
  public:
    explicit binary( const T value, const char *sep = " " )
      : _value( value ), _sep( sep ) {}
 
    friend ostream& operator<<( ostream& os, const binary& b ) {
      return b._manip_value( os, b );
    }
  private:
    const T     _value;
    const char *_sep;
 
    ostream& _manip_value( ostream& os, const binary& b ) const {
      // Print each bit of the value
      // Separate bytes by b._sep
      for ( int bit = sizeof b._value * 8 - 1; bit >= 0; --bit ) {
        os<< ( ( b._value & ( 1 << bit ) ) != 0 );
        if ( bit % 8 == 0 ) os<< b._sep;
      }
 
      return os;
    }
 
    // Hide the assignment operator because of warnings
    binary<T> operator=( const binary<T>& );
  };
 
  template <>
  class binary<string> {
  public:
    explicit binary( const string& value, const char *sep = " " )
      : _value( value ), _sep( sep ) {}
 
    friend ostream& operator<<( ostream& os, const binary& b ) {
      return b._manip_string( os, b );
    }
  private:
    const string  _value;
    const char   *_sep;
 
    ostream& _manip_string( ostream& os, const binary& b ) const {
      // Print each bit of each character
      // Separate characters by b._sep
      for ( const char *p = b._value.c_str(); *p != '\0'; ++p ) {
        for ( int bit = 7; bit >= 0; --bit )
          os<< ( ( ( *p >> bit ) & 1 ) != 0 );
        os<< b._sep;
      }
 
      return os;
    }
 
    // Hide the assignment operator because of warnings
    binary<string> operator=( const binary<string>& );
  };
}
 
int main() {
  cout<< hamrick::binary<int>( 1234 ) <<endl;
  cout<< hamrick::binary<string>( "ABCD" ) <<endl;
 
  for ( int a = 0; a < 256; a++ )
    cout<< hamrick::binary<char>( a ) <<endl;
 
  return 0;
}

#include <iostream> // for C++ I/O
#include <string>   // for C++ strings
#include <bitset>
#include <limits>
using namespace std;
 
namespace hamrick 
{
  enum { char_bits = numeric_limits<unsigned char>::digits };
  template <typename T>  class binary
  {
    public:
      explicit binary( const T value, const char *sep = " " )
         : _value( value ), _sep( sep ) {}
 
      friend ostream& operator<<( ostream& os, const binary& b )
      {
        typedef bitset< sizeof(T)*char_bits > bs ;
        return os << bs( b._value ) << b._sep ;
      }
    private:
      T  _value;
      string _sep;
  };
 
  template <>  class binary<string> 
  {
    public:
      explicit binary( const string& value, const char *sep = " " )
        : _value( value ), _sep( sep ) {}
 
    friend ostream& operator<<( ostream& os, const binary& b )
    {
      for( size_t i=0 ; i < b._value.size() ; ++i )
        os << bitset< char_bits >( b._value[i] ) << b._sep ;
      return os ;
    }
    private:
      string _value;
      string _sep;
  };
}
 
int main()
{
  cout<< hamrick::binary<int>( 1234 ) <<endl;
  cout<< hamrick::binary<string>( "ABCD" ) <<endl;
 
  for ( int a = 0; a < 256; a++ )
    cout<< hamrick::binary<char>( a ) <<endl;
 
  return 0;
}

binary<int> to_binary( int n )
{
  char does_not_exist_once_fn_returns[] = "\n" ;
  binary<int> ret( n, sep ) ;
  return ret ;
}

struct person
{
  const string name ; // name cannot be changed
  string address ; // address can change
  bool  operator== (  const person&  that ) const ;
  // both const qualifiers are required for const-correctness 
};

  template <typename T>  class binary
  {
    public:
      explicit binary( const T value, const char *sep = " " )
         : _value( value ), _sep( sep ) {}
 
      friend ostream& operator<<( ostream& os, const binary& b )
      {
        bitset< sizeof(T)*char_bits > bs( b._value ) ;
        const string& str = bs.to_string() ;
        for( size_t i=0 ; i<sizeof(T) ; ++i )
           os << str.substr( i*char_bits, char_bits ) << b._sep ;
        return os ;
      }
    private:
      T  _value;
      string _sep;
  };

struct S
{
  const int c ; // never modifiable, even if S is modifiable
  int i ; // modifiable if S is modifiable, const otherwise
  mutable int m ; // always modifiable (never const even if S is const)
  S( int ii ) : c(ii) {}
};
 
void foobar( S* ps, const S* pcs )
{
  // both ps->c and pcs->c are of type const int; both are non-modifiable
 //  ps->i is non-const, pcs->i is const
 //  both ps->m and pcs->m are non-const, both are modifiable
}