home | help 
std::basic_...tream::span(3)   C++ Standard Libary  std::basic_...tream::span(3)

NAME
     std::basic_ispanstream::span - std::basic_ispanstream::span

Synopsis
	std::span<const CharT> span() const noexcept; (1) (since C++23)
	void span( std::span<CharT> s ) noexcept;     (2) (since C++23)
	template< class SpanLike >		      (3) (since C++23)
	void span( SpanLike&& r ) noexcept;

	1) Gets a span referencing the written area if std::ios_base::out is set
     in the open
	mode of the wrapped std::basic_spanbuf, or a span referencing the under-
     lying buffer
	otherwise.
	2) Makes the wrapped std::basic_spanbuf perform I/O on the buffer refer-
     enced by s.
	3) Same as (2), except that s is obtained as if by
	std::span<const CharT> cs{std::forward<SpanLike>(r)};
	std::span<CharT> s{const_cast<CharT*>(cs.data()), cs.size()};
	.  This  overload  participates  in overload resolution only if SpanLike
     models
	borrowed_range,   std::convertible_to<SpanLike,   std::span<CharT>>   is
     false, and
	std::convertible_to<SpanLike, std::span<const CharT>> is true.

Parameters
	s  -  std::span  referencing the storage to be use as the new underlying
     buffer of
	    stream
	r - borrowed_range to be use as the new underlying buffer of stream

Return value
	1) A std::span referencing the underlying buffer or  written  area,  de-
     pending on the
	open mode of the wrapped std::basic_spanbuf.
	2,3) (none)

Example
     // Run this code

      #include <cassert>
      #include <iostream>
      #include <span>
      #include <spanstream>

      int main()
      {
	  char out_buf[16];
	  std::ospanstream ost{std::span<char>{out_buf}};
	  ost << "C++" << ' ' << 23 << '\0'; // note explicit null-termination
	  auto sp = ost.span();
	  assert(
	      sp[0] == 'C' && sp[1] == '+' && sp[2] == '+' &&
	      sp[3] == ' ' && sp[4] == '2' && sp[5] == '3' &&
	      sp[6] == '\0'
	  );
	  std::cout << "sp.data(): [" << sp.data() << "]\n";
	  std::cout << "out_buf: [" << out_buf << "]\n";
	  // spanstream uses out_buf as internal storage, no allocations
	  assert(static_cast<char*>(out_buf) == sp.data());

	  const char in_buf[] = "X Y 42";
	  std::ispanstream ist{std::span<const char>{in_buf}};
	  assert(static_cast<const char*>(in_buf) == ist.span().data());
	  char c;
	  ist >> c;
	  assert(c == 'X');
	  ist >> c;
	  assert(c == 'Y');
	  int i;
	  ist >> i;
	  assert(i == 42);
	  ist >> i; // buffer is exhausted
	  assert(!ist);
      }

Output:
      sp.data(): [C++ 23]
      out_buf: [C++ 23]

See also
	span	obtains or initializes an underlying buffer according to mode
	(C++23) (public member function of std::basic_spanbuf<CharT,Traits>)

http://cppreference.com 	   2024.06.10	    std::basic_...tream::span(3)
home | help