Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
std::bitset::bitset(3)	      C++ Standard Libary	std::bitset::bitset(3)

NAME
       std::bitset::bitset - std::bitset::bitset

Synopsis
	  bitset();						    (until
								    C++11)
	  constexpr bitset() noexcept;				    (since
								    C++11)
	  bitset(	    unsigned	       long	      val	    );
       (until
									    C++11)
	  constexpr	bitset(	    unsigned	 long	  long	    val	     )
       (since
	  noexcept;
       C++11)
	  template< class CharT, class Traits, class Alloc
	  >

	  explicit bitset( const
	  std::basic_string<CharT,Traits,Alloc>& str,
	  typename
       (until
	  std::basic_string<CharT,Traits,Alloc>::size_type
       C++11)
	  pos =	0,
	  typename
	  std::basic_string<CharT,Traits,Alloc>::size_type

	  n = std::basic_string<CharT,Traits,Alloc>::npos
	  );
	  template< class CharT, class Traits, class Alloc  (1)
	  >
								(2)
	  explicit bitset( const
	  std::basic_string<CharT,Traits,Alloc>&     str,		   (3)
       (since
	  typename
       C++11)
	  std::basic_string<CharT,Traits,Alloc>::size_type
       (constexpr
	  pos				    =				    0,
       since
	  typename
       C++23)
	  std::basic_string<CharT,Traits,Alloc>::size_type
	  n = std::basic_string<CharT,Traits,Alloc>::npos,
	  CharT	zero = CharT('0'),

	  CharT	one = CharT('1') );
	  template< class CharT	>
										    (since
	  explicit	    bitset(	     const	   CharT*	  str,
       C++11)
	  typename			   std::basic_string<CharT>::size_type
       (4)     (constexpr
	  n		     =		       std::basic_string<CharT>::npos,
       since
	  CharT		      zero		  =		   CharT('0'),
       C++23)

	  CharT	one = CharT('1') );

	  Constructs a new bitset from one of several optional data sources:

	  1)  Default  constructor.  Constructs	 a bitset with all bits	set to
       zero.
	  2) Constructs	a bitset, initializing	the  first  (rightmost,	 least
       significant) M bit
	  positions  to	 the  corresponding  bit values	of val,	where M	is the
       smaller of the
	  number of bits in an unsigned	long long and the number of bits N  in
       the bitset being
	  constructed. If M is less than N (the	bitset is longer than
	  32
	  (until C++11)
	  64
	  (since C++11)	bits, for typical implementations of unsigned
	  long
	  (since  C++11)long),	the remaining bit positions are	initialized to
       zeroes.
	  3) Constructs	a bitset using the characters in the std::basic_string
       str. An
	  optional starting position pos and length n can be provided, as well
       as characters
	  denoting alternate values for	 set  (one)  and  unset	 (zero)	 bits.
       Traits::eq() is used
	  to compare the character values.
	  The effective	length of the initializing string is min(n, str.size()
       - pos).
	  If  pos  > str.size(), this constructor throws std::out_of_range. If
       any characters
	  examined in str are not zero or one,	it  throws  std::invalid_argu-
       ment.
	  4) Similar to	(3), but uses a	CharT* instead of a std::basic_string.
       Equivalent to

	bitset(n == basic_string<CharT>::npos
		  ? basic_string<CharT>(str)
		  : basic_string<CharT>(str, n), 0, n, zero, one)

Parameters
	  val  - number	used to	initialize the bitset
	  str  - string	used to	initialize the bitset
	  pos  - a starting offset into	str
	  n    - number	of characters to use from str
	  one  - alternate character for set bits in str
	  zero - alternate character for unset bits in str

Exceptions
	  3)  std::out_of_range	 if pos	> str.size(), std::invalid_argument if
       any character is
	  not one or zero
	  4) std::invalid_argument if any character is not one or zero

Example
       // Run this code

	#include <bitset>
	#include <string>
	#include <iostream>
	#include <climits>

	int main()
	{
	    // empty constructor
	    std::bitset<8> b1; // [0,0,0,0,0,0,0,0]

	    // unsigned	long long constructor
	    std::bitset<8> b2(42);	    // [0,0,1,0,1,0,1,0]
	    std::bitset<70> bl(ULLONG_MAX);  //	 [0,0,0,0,0,0,1,1,1,...,1,1,1]
       in C++11
	    std::bitset<8> bs(0xfff0);	    // [1,1,1,1,0,0,0,0]

	    // string constructor
	    std::string	bit_string = "110010";
	    std::bitset<8> b3(bit_string);	 // [0,0,1,1,0,0,1,0]
	    std::bitset<8> b4(bit_string, 2);	 // [0,0,0,0,0,0,1,0]
	    std::bitset<8> b5(bit_string, 2, 3); // [0,0,0,0,0,0,0,1]

	    // string constructor using	custom zero/one	digits
	    std::string	alpha_bit_string = "aBaaBBaB";
	    std::bitset<8> b6(alpha_bit_string,	0, alpha_bit_string.size(),
			      'a', 'B');	 // [0,1,0,0,1,1,0,1]

	    // char* constructor using custom digits
	    std::bitset<8> b7("XXXXYYYY", 8, 'X', 'Y');	// [0,0,0,0,1,1,1,1]

	    std::cout <<   "b1:	" << b1	<< "\nb2: " << b2 << "\nbl: " << bl
		      << "\nbs:	" << bs	<< "\nb3: " << b3 << "\nb4: " << b4
		      << "\nb5:	" << b5	<< "\nb6: " << b6 << "\nb7: " << b7 <<
       '\n';
	}

Possible output:
	b1: 00000000
	b2: 00101010
	bl:
       0000001111111111111111111111111111111111111111111111111111111111111111
	bs: 11110000
	b3: 00110010
	b4: 00000010
	b5: 00000001
	b6: 01001101
	b7: 00001111

See also
	  set	sets bits to true or given value
		(public	member function)
	  reset	sets bits to false
		(public	member function)

http://cppreference.com		  2022.07.31		std::bitset::bitset(3)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::bitset::bitset&sektion=3&manpath=FreeBSD+Ports+15.0>

home | help