bitset man page on Solaris

Man page or keyword search:  
man Server   20652 pages
apropos Keyword Search (all sections)
Output format
Solaris logo
[printable version]

bitset(3C++)			       -			  bitset(3C++)

Standard C++ Library Copyright 1998, Rogue Wave Software, Inc.

NAME
       bitset

	-  A template class and related functions for storing and manipulating
       fixed-size sequences of bits.

SYNOPSIS
       #include <bitset>
       template <size_t N>
       class bitset ;

DESCRIPTION
       bitset<size_t_N> is a class that describes objects  that	 can  store  a
       sequence	 consisting  of a fixed number of bits, N. Each bit represents
       either the value zero (reset) or one (set) and has a non-negative posi‐
       tion pos.

ERRORS AND EXCEPTIONS
       Bitset constructors and member functions may report the following three
       types of errors - each associated with a distinct exception:

       ·    Invalid-argument error or invalid_argument() exception;

       ·    Out-of-range error or out_of_range() exception;

       ·    Overflow error or over-flow_error() exception;

       If exceptions are not supported on your compiler, you get an  assertion
       failure instead of an exception.

INTERFACE
       template <size_t N>
       class bitset {

       public:

       // bit reference:

 class reference {
  friend class bitset;
 public:

   ~reference();
  reference& operator= (bool);
  reference& operator= (const reference&);
  bool operator~() const;
  operator bool() const;
  reference& flip();
  };

// Constructors
 bitset ();
 bitset (unsigned long);
 template<class charT, class traits, class Allocator>
 explicit bitset
	   (const basic_string<charT, traits, Allocator>,
	   typename basic_string<charT, traits,
				 Allocator>::size_type=0,
	   typename basic_string<charT, traits,
				 Allocator>::size_type=
	   basic_string<charT, traits, Allocator>::npos);
 bitset (const bitset<N>&);
 bitset<N>& operator= (const bitset<N>&);

// Bitwise Operators and Bitwise Operator Assignment
  bitset<N>& operator&= (const bitset<N>&);
  bitset<N>& operator|= (const bitset<N>&);
  bitset<N>& operator^= (const bitset<N>&);
  bitset<N>& operator<<= (size_t);
  bitset<N>& operator>>= (size_t);

// Set, Reset, Flip
  bitset<N>& set ();
  bitset<N>& set (size_t, int = 1);
  bitset<N>& reset ();
  bitset<N>& reset (size_t);
  bitset<N> operator~() const;
  bitset<N>& flip ();
  bitset<N>& flip (size_t);

// element access
  reference operator[] (size_t);
  unsigned long to_ulong() const;
  template<class charT, class traits, class Allocator>
  basic_string<charT, traits, Allocator> to_string();
  size_t count() const;
  size_t size() const;
  bool operator== (const bitset<N>&) const;
  bool operator!= (const bitset<N>&) const;
  bool test (size_t) const;
  bool any() const;
  bool none() const;
  bitset<N> operator<< (size_t) const;
  bitset<N> operator>> (size_t) const;

};

// Non-member operators
template <;size_t N>
bitset<;N> operator& (const bitset<N>&, const bitset<N>&);

template <;size_t N>
bitset<;N> operator| (const bitset<N>&, const bitset<N>&);

template <;size_t N>
bitset<;N> operator^ (const bitset<N>&, const bitset<N>&);

template <;size_t N>
istream& operator>> (istream&, bitset<N>&);

template <;size_t N>
ostream& operator<;< (ostream&, const bitset<N>&)

CONSTRUCTORS
       bitset();

   Constructs  an  object  of  class bitset<N>, initializing all bit values to
   zero.

bitset(unsigned long val);

   Constructs an object of class bitset<N>, initializing the first M bit  val‐
   ues	to  the corresponding bits in val. M is the smaller of N and the value
   CHAR_BIT * sizeof(unsigned long). If M < N,	remaining  bit	positions  are
   initialized to zero. Note: CHAR_BIT is defined in <climits>.

   template<class charT, class traits, class Allocator>

explicit

bitset (const basic_string<;charT, traits, Allocator>,
       typename basic_string<charT, traits,
			     Allocator>::size_type=0,
       typename basic_string<charT, traits,
			     Allocator>::size_type=
       basic_string<charT, traits, Allocator>::npos);

   Determines  the  effective  length  rlen  of the initializing string as the
   smaller of n and str.size() - pos. The function throws an  invalid_argument
   exception  if any of the rlen characters in str, beginning at position pos,
   is other than 0 or 1. Otherwise, the function constructs an object of class
   bitset<N>, initializing the first M bit positions to values determined from
   the corresponding characters in the string str. M is the smaller of	N  and
   rlen.  This constructor expects pos <= str.size(). If that is not true, the
   constructor throws an out_of_range exception.

bitset(const bitset<;N>& rhs);

   Creates a copy of rhs.

ASSIGNMENT OPERATORS
       bitset<N>&
       operator=(const bitset<N>& rhs);

   Erases all bits in self, then inserts into self a copy of each bit in  rhs.
   Returns a reference to *this.

OPERATORS
       bool
       operator==(const bitset<N>& rhs) const;

   Returns  true  if  the  value of each bit in *this equals the value of each
   corresponding bit in rhs. Otherwise returns false.

bool
operator!=(const bitset<N>& rhs) const;

   Returns true if the value of any bit in *this is not equal to the value  of
   the corresponding bit in rhs. Otherwise returns false.

bitset<;N>&
operator&=(const bitset<N>& rhs);

   Clears  each	 bit  in *this for which the corresponding bit in rhs is clear
   and leaves all other bits unchanged. Returns *this.

bitset<;N>&
operator|=(const bitset<N>& rhs);

   Sets each bit in *this for which the corresponding bit in rhs is  set,  and
   leaves all other bits unchanged. Returns *this.

bitset<;N>&
operator^=(const bitset<N>& rhs);

   Toggles  each  bit  in *this for which the corresponding bit in rhs is set,
   and leaves all other bits unchanged. Returns *this.

bitset<;N>&
operator<;<=(size_t pos);

   Replaces each bit at position I with 0 if I < pos or with the value of  the
   bit at I - pos if I >= pos. Returns *this.

bitset<;N>&
operator>>=(size_t pos);

   Replaces  each  bit at position I with 0 if pos >= N-I or with the value of
   the bit at position I + pos if pos < N-I. Returns *this.

bitset<;N>&
operator>>(size_t pos) const;

   Returns bitset<N>(*this) >>= pos.

bitset<;N>&
operator<;<(size_t pos) const;

   Returns bitset<N>(*this) <<= pos.

bitset<;N>
operator~() const;

   Returns the bitset that is the logical complement of each bit in *this.

bitset<;N>
operator&(const bitset<;N>& lhs,
	 const bitset<N>& rhs);

   lhs gets logical AND of lhs with rhs.

bitset<;N>
operator|(const bitset<N>& lhs,
	 const bitset<N>& rhs);

   lhs gets logical OR of lhs with rhs.

bitset<;N>
operator^(const bitset<N>& lhs,
	 const bitset<N>& rhs);

   lhs gets logical XOR of lhs with rhs.

template <;size_t N>
istream&
operator>>(istream& is, bitset<N>& x);

   Extracts up to N characters (single-byte) from is. Stores these  characters
   in a temporary object str of type string, then evaluates the expression x =
   bitset<N>(str). Characters are extracted and stored until any of  the  fol‐
   lowing occurs:

	-    N characters have been extracted and stored

	-    An end-of-file is reached on the input sequence

	-    The  next	character  is  neither	'0' nor '1'. In this case, the
	     character is not extracted

   Returns is.

template <;size_t N>
ostream&
operator<;<(ostream& os, const bitset<N>& x);

   Returns os << x.to_string()

MEMBER FUNCTIONS
       bool
       any() const;

   Returns true if any bit in *this is set. Otherwise returns false.

size_t
count() const;

   Returns a count of the number of bits set in *this.

bitset<;N>&
flip();

   Flips all bits in *this, and returns *this.

bitset<;N>&
flip(size_t pos);

   Flips the bit at position  pos  in  *this  and  returns  *this.  Throws  an
   out_of_range exception if pos does not correspond to a valid bit position.

bool
none() const;

   Returns true if no bit in *this is set.   Otherwise returns false.

bitset<;N>&
reset();

   Resets all bits in *this, and returns *this.

bitset<;N>&
reset(size_t pos);

   Resets  the	bit at position pos in *this. Throws an out_of_range exception
   if pos does not correspond to a valid bit position.

bitset<;N>&
set();

   Sets all bits in *this, and returns *this.

bitset<;N>&
set(size_t pos, int val = 1);

   Stores a new value in the bits at position pos in *this. If val is nonzero,
   the	stored	value  is  one,	 otherwise  it is zero. Throws an out_of_range
   exception if pos does not correspond to a valid bit position.

size_t
size() const;

   Returns the template parameter N.

bool
test(size_t pos) const;

   Returns true if the bit at position pos  is	set.  Throws  an  out_of_range
   exception if pos does not correspond to a valid bit position.

   template<class charT, class traits, class Allocator>
   basic_string<charT, traits, Allocator>
   to_string();

   Returns an object of type string, N characters long.

   Each	 position  in  the new string is initialized with a character ('0' for
   zero and '1' for one) representing the value stored	in  the	 corresponding
   bit position of *this. Character position N - 1 corresponds to bit position
   0. Subsequent decreasing character positions correspond to  increasing  bit
   positions.

unsigned long
to_ulong() const;

   Returns  the	 integral  value corresponding to the bits in *this. Throws an
   overflow_error if these bits cannot be represented as type unsigned long.

SEE ALSO
       Containers

Rogue Wave Software		  02 Apr 1998			  bitset(3C++)
[top]

List of man pages available for Solaris

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Tweet
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
....................................................................
Vote for polarhome
Free Shell Accounts :: the biggest list on the net