std::println(3)

💖 std::println(3) — C++ Standard Libary, but make it cute 💖

okay so bestie, welcome to the std::println(3) page, straight from the C++ Standard Libary. this is the overload family that formats your args according to a format string, appends '\n' so every output ends with a new-line, and prints the result to a stream. iconic. 🎀

🌸 NAME 🌸

std::println — std::println (yes, she named the section after herself 💅)

✨ 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)

so what does she do? She formats args according to the format string fmt with an appended '\n' — which means that each output ends with a new-line — and prints the result to a stream. 💖

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

🚨 warning bestie: 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). no cap, take that seriously.

🦋 Parameters 🦋

• stream — output file stream to write to. 🫶
• fmt — 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

• arg-id — 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. The arg-ids in a format string must all be present or all be omitted. Mixing manual and automatic indexing is an error.
• format-spec — the format specification defined by the std::formatter specialization for the corresponding argument. Cannot start with }.

then the flavor of format-spec depends on the type, bestie:

• 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. 🍓

😭 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 implementations make them available in C++23 mode. slay for backwards-ish vibes. ✨

🧋 Feature-test macro tea 🧋

• __cpp_lib_print — value 202207L, std (C++23), feature: Formatted output.
• __cpp_lib_print — value 202403L, std (C++26), feature: Formatted output with stream locking (DR23).
• __cpp_lib_format — value 202207L, std (C++23), feature: Exposing std::basic_format_string.

🌈 Example 🌈

run this code, bestie:

// 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 (C++23) — prints to stdout or a file stream using formatted representation of the arguments (function template).
• println(std::ostream) (C++23) — outputs formatted representation of the arguments with appended '\n' (function template).
• format (C++20) — stores formatted representation of the arguments in a new string (function template).
• printf, fprintf, sprintf, snprintf (C++11) — prints formatted output to stdout, a file stream or a buffer (function).

big sparkle kiss from http://cppreference.com 💋 — page dated 2024.06.10, and yes this was std::println(3). byeeee 🫶✨