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

FreeBSD Manual Pages

  
 
  

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

NAME
       std::println - std::println

Synopsis
	  Defined in header <print>
	  template< class... Args >					   (1)
       (since C++23)
	  void println(	std::format_string<Args...> fmt, Args&&... args	);
	  template< class... Args >

	  void println(	std::FILE* stream,				   (2)
       (since C++23)

			std::format_string<Args...> fmt, Args&&... args	);
	  void println();						   (3)
       (since C++26)
	  void println(	std::FILE* stream );				   (4)
       (since C++26)

	  Format  args	according  to the format string	fmt with appended '\n'
       (which means that
	  each output ends with	a new-line), and print the result to a stream.

	  1)	Equivalent    to    std::println(stdout,    fmt,     std::for-
       ward<Args>(args)...).
	  2)	 Equivalent	to     std::print(stream,    std::runtime_for-
       mat(std::string(fmt.get()) +
	  '\n'),
		     std::forward<Args>(args)...).
	  3) Equivalent	to std::println(stdout).
	  4) Equivalent	to std::print(stream, "\n").

	  The behavior is undefined if std::formatter<Ti, char>	does not  meet
       the
	  BasicFormatter requirements for any Ti in Args (as required by
	  std::make_format_args).

Parameters
	  stream  - output file	stream to write	to

		    an	object	that  represents the format string. The	format
       string consists of
		      *	ordinary characters (except { and }), which are	copied
       unchanged to
			the output,
		      *	escape sequences {{ and	}}, which are replaced with  {
       and }
			respectively in	the output, and
		      *	replacement fields.

		    Each replacement field has the following format:

		    { arg-id (optional)	}		(1)
		    { arg-id (optional)	: format-spec }	(2)

		    1) replacement field without a format specification
		    2) replacement field with a	format specification

				  specifies  the index of the argument in args
       whose value is
				  to be	used for formatting; if	it is omitted,
       the arguments
				  are used in order.
		    arg-id	-
				  The arg-ids in a format string must  all  be
       present or all
				  be  omitted. Mixing manual and automatic in-
       dexing is an
				  error.
	  fmt	  -		  the  format  specification  defined  by  the
       std::formatter
		    format-spec	 -  specialization for the corresponding argu-
       ment. Cannot start
				  with }.

		      *	For basic types	and standard string types, the	format
       specification is
			interpreted as standard	format specification.
		      *	 For  chrono types, the	format specification is	inter-
       preted as chrono
			format specification.

		      *	For range types, the format  specification  is	inter-
       preted
			as range format	specification.
		      *	For std::pair and std::tuple, the format specification
			is interpreted as tuple	format specification.
		      *	 For  std::thread::id  and  std::stacktrace_entry, see
       (since C++23)
			thread id format specification and stacktrace entry
			format specification.
		      *	For std::basic_stacktrace, no format specifier is
			allowed.

		      *	  For	std::filesystem::path,	 see	path	format
       (since C++26)
			specification.

		      *	 For other formattable types, the format specification
       is determined by
			user-defined formatter specializations.
	  args... - arguments to be formatted

Exceptions
	    * std::bad_alloc on	allocation failure.
	    * std::system_error, if writing to the stream fails.
	    *  Propagates  any	exception  thrown  by  used  formatters,  e.g.
       std::format_error.

Notes
	  Although  overloads  (3,4) are added in C++26, all known implementa-
       tions make them
	  available in C++23 mode.

	  Feature-test macro  Value    Std		   Feature
			     202207L (C++23) Formatted output
	  __cpp_lib_print    202403L  (C++26)  Formatted  output  with	stream
       locking
				     (DR23)
	  __cpp_lib_format   202207L (C++23) Exposing std::basic_format_string

Example
       // Run this code

	#include <print>

	int main()
	{
	    // Each call to std::println ends with new-line
	    std::println("Please"); // overload	(1)
	    std::println("enter"); // (1)

	    std::print("pass");
	    std::print("word");

	    std::println();   //  (3);	valid  since  C++26;  same  effect  as
       std::print("\n");
	}

Output:
	Please
	enter
	password

See also
	  print			prints to stdout or a file stream  using  for-
       matted
	  (C++23)		representation of the arguments
				(function template)
	  println(std::ostream)	 outputs formatted representation of the argu-
       ments with
	  (C++23)		appended '\n'
				(function template)
	  format		stores formatted representation	of  the	 argu-
       ments in	a new
	  (C++20)		string
				(function template)
	  printf
	  fprintf		 prints	 formatted  output  to	stdout,	a file
       stream or a buffer
	  sprintf		(function)
	  snprintf
	  (C++11)

http://cppreference.com		  2024.06.10		       std::println(3)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::println&manpath=FreeBSD+Ports+15.1.quarterly>

home | help