std::print(std::ostream)(3)

NAME
std::print(std::ostream) - std::print(std::ostream)

Synopsis
   Defined in header <ostream>
   template< class... Args >
   void print( std::ostream& os, std::format_string<Args...> fmt, (since C++23)
   Args&&... args );
   Formats args according to the format string fmt, and inserts the result into os
   stream.
   If the ordinary literal encoding is UTF-8, equivalent to:
     * std::vprint_unicode(os, fmt.get(), std::make_format_args(args...));. Otherwise,
     * std::vprint_nonunicode(os, fmt.get(), std::make_format_args(args...));.
   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
   os - output stream to insert data into
             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-id s in a format string must all be present or all
                        be omitted. Mixing manual and automatic indexing is an
                        error.
   fmt - the format specification defined by the std::formatter
             format-spec - specialization for the corresponding argument. 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 interpreted as chrono
                 format specification.
               * For range types, the format specification is interpreted
                 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

Return value
   (none)

Exceptions
     * std::bad_alloc on allocation failure.
     * Propagate any exception thrown by any formatter, e.g. std::format_error, without
       regard to the value of os.exceptions() and without turning on ios_base::badbit
       in the error state of os.
     * May throw ios_base::failure caused by os.setstate(ios_base::badbit) which is
       called if an insertion into os fails.

Notes
   Feature-test macro Value Std Feature
   __cpp_lib_print 202207L (C++23) Formatted output
   __cpp_lib_format 202207L (C++23) Exposing std::basic_format_string

Example
// Run this code
 #include <array>
 #include <cctype>
 #include <cstdio>
 #include <format>
 #include <numbers>
 #include <ranges>
 #include <sstream>
 int main()
 {
     std::array<char, 24> buf;
     std::format_to(buf.begin(), "{:.15f}", std::numbers::sqrt2);
     unsigned num{}, sum{};
     auto v = buf
            | std::views::filter(isdigit)
            | std::views::transform([](char x) { return x - '0'; })
            | std::views::take_while([&sum](char) { return sum < 42; });
     for (auto n : v)
         sum += n, ++num;
     std::stringstream stream;
 #ifdef __cpp_lib_print
     std::print(stream,
 #else
     stream << std::format(
 #endif
         "√2 = {}...\n"
         "The sum of its first {} digits is {}{}",
         std::numbers::sqrt2, num, sum, '.'
     );
     std::puts(stream.str().data());
 }

Output:
 √2 = 1.4142135623730951...
 The sum of its first 13 digits is 42.

See also
   println(std::ostream) outputs formatted representation of the arguments with
   (C++23) appended '\n'
                        (function template)
   print prints to stdout or a file stream using formatted
   (C++23) representation of the arguments
                        (function template)
   format stores formatted representation of the arguments in a new
   (C++20) string
                        (function template)