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

FreeBSD Manual Pages

  
 
  

home | help 
std::basic_...f::underflow(3) C++ Standard Libarystd::basic_...f::underflow(3)

NAME
       std::basic_streambuf::underflow - std::basic_streambuf::underflow

Synopsis
	  protected:
	  virtual int_type underflow();

	  Ensures  that	 at least one character	is available in	the input area
       by updating the
	  pointers to the input	area (if needed) and reading more data in from
       the input
	  sequence (if applicable). Returns the	value of that character	 (con-
       verted to int_type
	  with Traits::to_int_type(c)) on success or Traits::eof() on failure.

	  The function may update gptr,	egptr and eback	pointers to define the
       location	of
	  newly	 loaded	 data  (if any). On failure, the function ensures that
       either gptr() ==
	  nullptr or gptr() == egptr.

	  The base class version of the	function  does	nothing.  The  derived
       classes may
	  override  this function to allow updates to the get area in the case
       of exhaustion.

Parameters
	  (none)

Return value
	  The value of the character pointed to	by the get pointer  after  the
       call on success,
	  or Traits::eof() otherwise.

	  The base class version of the	function returns traits::eof().

Note
	  The  public  functions  of std::streambuf call this function only if
       gptr() == nullptr
	  or gptr() >= egptr().

Example
       // Run this code

	#include <iostream>
	#include <sstream>

	class null_filter_buf :	public std::streambuf {
	    std::streambuf* src;
	    char ch; //	single-byte buffer
	protected:
	    int	underflow() {
		traits_type::int_type i;
		while ((i = src->sbumpc()) == '\0') ; // skip zeroes
		if (!traits_type::eq_int_type(i, traits_type::eof())) {
		    ch = traits_type::to_char_type(i);
		    setg(&ch, &ch, &ch+1); // make one read position available
		}
		return i;
	    }
	public:
	    null_filter_buf(std::streambuf* buf) : src(buf) {
		setg(&ch, &ch+1, &ch+1); // buffer is initially	full
	    }
	};

	void filtered_read(std::istream& in)
	{
	    std::streambuf* orig = in.rdbuf();
	    null_filter_buf buf(orig);
	    in.rdbuf(&buf);
	    for(char c;	in.get(c); )
		    std::cout << c;
	    in.rdbuf(orig);
	}

	int main()
	{
	    char a[] = "This i\0s \0an e\0\0\0xample";
	    std::istringstream in(std::string(std::begin(a), std::end(a)));
	    filtered_read(in);
	}

Output:
	This is	an example

See also
	  uflow	    reads characters from the associated input sequence	to the
       get area	and
	  [virtual] advances the next pointer
		    (virtual protected member function)
	  overflow  writes characters to the associated	output	sequence  from
       the put area
	  [virtual] (virtual protected member function)
	  underflow reads from the associated file
	  [virtual]  (virtual  protected  member  function of std::basic_file-
       buf<CharT,Traits>)
	  underflow returns the	next character available in the	input sequence
	  [virtual] (virtual protected member function of
		    std::basic_stringbuf<CharT,Traits,Allocator>)
	  underflow reads a character from the input sequence without  advanc-
       ing the next
	  [virtual] pointer
		    (virtual protected member function of std::strstreambuf)

http://cppreference.com		  2022.07.31	 std::basic_...f::underflow(3)

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

home | help