[#index]
= Global namespace
:mrdocs:

== Namespaces

[cols="1,4"]
|===
| Name| Description
| xref:fmt.adoc[`fmt`] 
| Top&hyphen;level namespace for the &lcub;fmt&rcub; formatting library, wrapping all public API in the inline namespace `v12` used to version the library&apos;s ABI&period;
|===


== Macros

[cols="1,4"]
|===
| Name| Description
| xref:FMT_STATIC_FORMAT.adoc[`FMT&lowbar;STATIC&lowbar;FORMAT`] 
| Formats arguments according to the format string `fmt&lowbar;str` and produces a string of the exact required size at compile time&period; Both the format string and the arguments must be compile&hyphen;time expressions&period;
|===


== xref:fmt.adoc[fmt] namespace

Top&hyphen;level namespace for the &lcub;fmt&rcub; formatting library, wrapping all public API in the inline namespace `v12` used to version the library&apos;s ABI&period;

=== Namespaces

[cols="1,4"]
|===
| Name| Description
| xref:fmt/enums.adoc[`enums`] 
| Contains `format&lowbar;as` overloads that make enum types formattable by converting them to their underlying type&period;
| xref:fmt/safe_duration_cast.adoc[`safe&lowbar;duration&lowbar;cast`] 
| Helpers for converting between `std&colon;&colon;chrono&colon;&colon;duration` types without undefined behavior or erroneous results due to overflow&period;
|===


=== Types

[cols="1,4"]
|===
| Name| Description
| xref:fmt/basic_appender.adoc[`basic&lowbar;appender`] 
| An output iterator that appends to a buffer&period; It is used instead of `back&lowbar;insert&lowbar;iterator` to reduce symbol sizes and avoid the `&lt;iterator&gt;` dependency&period;
| xref:fmt/basic_cstring_view.adoc[`basic&lowbar;cstring&lowbar;view`] 
| A reference to a null&hyphen;terminated string&period; It can be constructed from a C string or `std&colon;&colon;string`&period;
| xref:fmt/basic_format_arg.adoc[`basic&lowbar;format&lowbar;arg`] 
| A formatting argument&period; `Context` is a template parameter for the compiled API where output can be unbuffered&period;
| xref:fmt/basic_format_args.adoc[`basic&lowbar;format&lowbar;args`] 
| A view of a collection of formatting arguments&period; To avoid lifetime issues it should only be used as a parameter type in type&hyphen;erased functions such as `vformat`&colon;
| xref:fmt/basic_fstring.adoc[`basic&lowbar;fstring`] 
| A `Char` counterpart of `fstring`&period; Use `basic&lowbar;format&lowbar;string` in the public API to prevent type deduction&period;
| xref:fmt/basic_memory_buffer.adoc[`basic&lowbar;memory&lowbar;buffer`] 
| A dynamically growing memory buffer for trivially copyable&sol;constructible types with the first `SIZE` elements stored in the object itself&period; Most commonly used via the `memory&lowbar;buffer` alias for `char`&period;
| xref:fmt/basic_ostream_formatter.adoc[`basic&lowbar;ostream&lowbar;formatter`] 
| Formats an object of type T that has an overloaded ostream operator&lt;&lt;&period;
| xref:fmt/basic_printf_context.adoc[`basic&lowbar;printf&lowbar;context`] 
| The formatting context used to evaluate `printf`&hyphen;style format strings&period;
| xref:fmt/basic_specs.adoc[`basic&lowbar;specs`] 
| Basic format specifiers for built&hyphen;in and string types&period;
| xref:fmt/basic_string_view.adoc[`basic&lowbar;string&lowbar;view`] 
| An implementation of `std&colon;&colon;basic&lowbar;string&lowbar;view` for pre&hyphen;C&plus;&plus;17 providing a subset of the API&period; `fmt&colon;&colon;basic&lowbar;string&lowbar;view` is used in the public API even if `std&colon;&colon;basic&lowbar;string&lowbar;view` is available to prevent issues when a library is compiled with a different `&hyphen;std` option than the client code (which is not recommended)&period;
| xref:fmt/buffered_file.adoc[`buffered&lowbar;file`] 
| A buffered file&period;
| xref:fmt/bytes.adoc[`bytes`] 
| A view over a `string&lowbar;view` that formats its contents as raw bytes rather than as text&period;
| xref:fmt/compiled_string.adoc[`compiled&lowbar;string`] 
| A compile&hyphen;time string which is compiled into fast formatting code&period;
| xref:fmt/conjunction-03.adoc[`conjunction`] 
| Logical AND of a list of traits, each exposing a `value` bool constant, short&hyphen;circuiting like `std&colon;&colon;conjunction`&period;
| xref:fmt/context.adoc[`context`] 
| A formatting context&period;
| xref:fmt/dynamic_format_arg_store.adoc[`dynamic&lowbar;format&lowbar;arg&lowbar;store`] 
| A dynamic list of formatting arguments with storage&period;
| xref:fmt/file.adoc[`file`] 
| A file&period; A closed file is represented by a file object with descriptor &hyphen;1&period; Methods that are not declared with noexcept may throw `fmt&colon;&colon;system&lowbar;error` in case of failure&period;
| xref:fmt/format_error.adoc[`format&lowbar;error`] 
| An error reported from a formatting function&period;
| xref:fmt/format_facet-03.adoc[`format&lowbar;facet`] 
| A locale facet that formats values in UTF&hyphen;8&period; It is parameterized on the locale to avoid the heavy &lt;locale&gt; include&period;
| xref:fmt/format_int.adoc[`format&lowbar;int`] 
| A fast integer formatter&period;
| xref:fmt/format_specs.adoc[`format&lowbar;specs`] 
| Format specifiers for built&hyphen;in and string types&period;
| xref:fmt/format_to_n_result.adoc[`format&lowbar;to&lowbar;n&lowbar;result`] 
| The result of `format&lowbar;to&lowbar;n`&period;
| xref:fmt/format_to_result.adoc[`format&lowbar;to&lowbar;result`] 
| The result of `format&lowbar;to` writing into a fixed&hyphen;size character array&period;
| xref:fmt/formatter-030.adoc[`formatter`] 
| A formatter for objects of type `T`&period;
| xref:fmt/fstring.adoc[`fstring`] 
| A compile&hyphen;time format string&period; Use `format&lowbar;string` in the public API to prevent type deduction&period;
| xref:fmt/generic_context.adoc[`generic&lowbar;context`] 
| The format context implementation used for output iterators other than `appender`, type&hyphen;erasing the output iterator and character types&period;
| xref:fmt/group_digits_view.adoc[`group&lowbar;digits&lowbar;view`] 
| A view holding an integer value to be formatted with digit grouping&period;
| xref:fmt/is_compiled_string.adoc[`is&lowbar;compiled&lowbar;string`] 
| A trait that detects whether `S` is a compile&hyphen;time string produced by `FMT&lowbar;COMPILE`, i&period;e&period; derives from `compiled&lowbar;string`&period;
| xref:fmt/is_container_adaptor.adoc[`is&lowbar;container&lowbar;adaptor`] 
| Specifies if `T` is a container adaptor (like `std&colon;&colon;stack`) that should be formatted as the underlying container&period;
| xref:fmt/is_contiguous-03.adoc[`is&lowbar;contiguous`] 
| Detects whether `T` stores its elements contiguously in memory&period;
| xref:fmt/is_range.adoc[`is&lowbar;range`] 
| Detects whether `T` is a range that should be formatted as a range, i&period;e&period; it has `begin`&sol;`end` but is not optional&hyphen;like or string&hyphen;like&period;
| xref:fmt/is_tuple_formattable.adoc[`is&lowbar;tuple&lowbar;formattable`] 
| Detects whether every element of tuple&hyphen;like type `T` is formattable with character type `C`&period;
| xref:fmt/is_tuple_like-06.adoc[`is&lowbar;tuple&lowbar;like`] 
| Detects whether `T` is a tuple&hyphen;like type (supports `std&colon;&colon;tuple&lowbar;size`) that is not also a range&period;
| xref:fmt/is_variant_like.adoc[`is&lowbar;variant&lowbar;like`] 
| Detects whether `T` is a variant&hyphen;like type, i&period;e&period; exposes the `std&colon;&colon;variant`&hyphen;style `index()`&sol;`std&colon;&colon;visit` interface&period;
| xref:fmt/join_view.adoc[`join&lowbar;view`] 
| A view over the iterator range `&lsqb;begin, end)&rsqb;` that formats its elements separated by `sep`, produced by `fmt&colon;&colon;join`&period;
| xref:fmt/loc_value.adoc[`loc&lowbar;value`] 
| A type&hyphen;erased formatting argument passed to a `format&lowbar;facet` for locale&hyphen;aware formatting&period;
| xref:fmt/locale_ref.adoc[`locale&lowbar;ref`] 
| A type&hyphen;erased reference to std&colon;&colon;locale to avoid the heavy &lt;locale&gt; include&period;
| xref:fmt/locking.adoc[`locking`] 
| Detects whether formatting an object of type `T` requires locking, e&period;g&period; because it accesses global state such as the current locale&period;
| xref:fmt/monostate.adoc[`monostate`] 
| An empty placeholder type used where a value is required by the API but carries no information, e&period;g&period; as the mapped type for arguments that don&apos;t match any supported formatting type&period;
| xref:fmt/nested_formatter.adoc[`nested&lowbar;formatter`] 
| Base class for formatters that nest another formatter and support applying a width and alignment to its overall output, such as `formatter&lt;std&colon;&colon;pair&lt;T, U&gt;&gt;`&period;
| xref:fmt/nested_view.adoc[`nested&lowbar;view`] 
| Pairs a value with the formatter that should be used to format it, so it can be formatted through a `formatter&lt;nested&lowbar;view&lt;T, Char&gt;, Char&gt;` specialization by an enclosing formatter&period;
| xref:fmt/parse_context-0a.adoc[`parse&lowbar;context`] 
| Parsing context consisting of a format string range being parsed and an argument counter for automatic indexing&period;
| xref:fmt/path.adoc[`path`] 
| A `std&colon;&colon;filesystem&colon;&colon;path` subclass whose `string()`&hyphen;like accessors return UTF&hyphen;8 encoded strings regardless of platform&period;
| xref:fmt/range_format_kind.adoc[`range&lowbar;format&lowbar;kind`] 
| Determines the `range&lowbar;format` used to format `T`, e&period;g&period; `map`, `set`, `string`, or `disabled` if `T` is not a formattable range&period;
| xref:fmt/range_formatter-02.adoc[`range&lowbar;formatter`] 
| Formats a range as a bracketed, separator&hyphen;delimited sequence of its elements&period;
| xref:fmt/rgb.adoc[`rgb`] 
| A color represented as separate red, green, and blue components&period;
| xref:fmt/runtime_format_string.adoc[`runtime&lowbar;format&lowbar;string`] 
| A format string that skips compile&hyphen;time checks and is validated at runtime instead, as returned by `runtime`&period;
| xref:fmt/static_format_result.adoc[`static&lowbar;format&lowbar;result`] 
| Holds a null&hyphen;terminated string of exactly `N &hyphen; 1` characters, produced by formatting a compiled format string at compile time&period;
| xref:fmt/string_buffer.adoc[`string&lowbar;buffer`] 
| A `std&colon;&colon;string`&hyphen;backed buffer that can be converted to a `writer`&period;
| xref:fmt/text_style.adoc[`text&lowbar;style`] 
| A text style consisting of foreground and background colors and emphasis&period;
| xref:fmt/tuple_join_view.adoc[`tuple&lowbar;join&lowbar;view`] 
| A view over `tuple` that formats its elements separated by `sep`, produced by `fmt&colon;&colon;join`&period;
| xref:fmt/vprintf_args.adoc[`vprintf&lowbar;args`] 
| A helper that maps a character type to the type&hyphen;erased argument list used with `basic&lowbar;printf&lowbar;context&lt;Char&gt;`&period;
| xref:fmt/writer.adoc[`writer`] 
| A writer to a buffered stream&period; It doesn&apos;t own the underlying stream&period;
|===


=== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:fmt/appender.adoc[`appender`] 
| A `basic&lowbar;appender` specialized for `char`&period;
| xref:fmt/basic_format_context.adoc[`basic&lowbar;format&lowbar;context`] 
| Format context type for a given output iterator and character type, resolving to `context` when `OutputIt` is `appender` and to `generic&lowbar;context&lt;OutputIt, Char&gt;` otherwise&period;
| xref:fmt/basic_format_parse_context.adoc[`basic&lowbar;format&lowbar;parse&lowbar;context`] 
| Alias of `parse&lowbar;context&lt;Char&gt;` kept for C&plus;&plus;20 `std&colon;&colon;format` compatibility&period;
| xref:fmt/basic_format_string.adoc[`basic&lowbar;format&lowbar;string`] 
| A format string for character type `Char` that is validated at compile time&period;
| xref:fmt/bool_constant.adoc[`bool&lowbar;constant`] 
| Alias for `std&colon;&colon;integral&lowbar;constant&lt;bool, B&gt;`, provided for compilers that predate C&plus;&plus;17&apos;s `std&colon;&colon;bool&lowbar;constant`&period;
| xref:fmt/buffered_context.adoc[`buffered&lowbar;context`] 
| Format context type used by `fmt&colon;&colon;format` overloads that write through a `back&lowbar;insert&lowbar;iterator`, resolving to `context` for `char` and to `generic&lowbar;context&lt;basic&lowbar;appender&lt;Char&gt;, Char&gt;` otherwise&period;
| xref:fmt/conditional_t.adoc[`conditional&lowbar;t`] 
| Alias for `std&colon;&colon;conditional&lt;B, T, F&gt;&colon;&colon;type`, provided for compilers that predate C&plus;&plus;14&apos;s `std&colon;&colon;conditional&lowbar;t`&period;
| xref:fmt/cstring_view.adoc[`cstring&lowbar;view`] 
| A `basic&lowbar;cstring&lowbar;view` for `char` strings&period;
| xref:fmt/day.adoc[`day`] 
| 
| xref:fmt/decay_t.adoc[`decay&lowbar;t`] 
| Alias for `std&colon;&colon;decay&lt;T&gt;&colon;&colon;type`, provided for compilers that predate C&plus;&plus;14&apos;s `std&colon;&colon;decay&lowbar;t`&period;
| xref:fmt/enable_if_t.adoc[`enable&lowbar;if&lowbar;t`] 
| Alias for `std&colon;&colon;enable&lowbar;if&lt;B, T&gt;&colon;&colon;type`, provided for compilers that predate C&plus;&plus;14&apos;s `std&colon;&colon;enable&lowbar;if&lowbar;t`&period;
| xref:fmt/format_args.adoc[`format&lowbar;args`] 
| Alias of `basic&lowbar;format&lowbar;args&lt;context&gt;` used by the default format API&period;
| xref:fmt/format_context.adoc[`format&lowbar;context`] 
| Alias of `context` kept for C&plus;&plus;20 `std&colon;&colon;format` compatibility&period;
| xref:fmt/format_parse_context.adoc[`format&lowbar;parse&lowbar;context`] 
| Alias of `parse&lowbar;context&lt;char&gt;` kept for C&plus;&plus;20 `std&colon;&colon;format` compatibility&period;
| xref:fmt/format_string.adoc[`format&lowbar;string`] 
| A format string that is validated at compile time&period;
| xref:fmt/is_formattable.adoc[`is&lowbar;formattable`] 
| A trait indicating whether `T` can be formatted with character type `Char`&period;
| xref:fmt/local_time.adoc[`local&lowbar;time`] 
| A time point on the local clock, with the given `Duration` resolution&period;
| xref:fmt/make_unsigned_t.adoc[`make&lowbar;unsigned&lowbar;t`] 
| Alias for `std&colon;&colon;make&lowbar;unsigned&lt;T&gt;&colon;&colon;type`, provided for compilers that predate C&plus;&plus;14&apos;s `std&colon;&colon;make&lowbar;unsigned&lowbar;t`&period;
| xref:fmt/memory_buffer.adoc[`memory&lowbar;buffer`] 
| A memory buffer for `char` with the default inline capacity&period;
| xref:fmt/month.adoc[`month`] 
| 
| xref:fmt/named_arg.adoc[`named&lowbar;arg`] 
| An argument bound to a name, as returned by `fmt&colon;&colon;arg`, that lets a format string refer to it by name instead of by position&period;
| xref:fmt/nullptr_t.adoc[`nullptr&lowbar;t`] 
| The type of the `nullptr` literal&period;
| xref:fmt/ostream_formatter.adoc[`ostream&lowbar;formatter`] 
| A `basic&lowbar;ostream&lowbar;formatter` for `char` strings&period;
| xref:fmt/printf_args.adoc[`printf&lowbar;args`] 
| The type&hyphen;erased argument list used with `printf&lowbar;context`&period;
| xref:fmt/printf_context.adoc[`printf&lowbar;context`] 
| A `basic&lowbar;printf&lowbar;context` for `char` strings&period;
| xref:fmt/remove_const_t.adoc[`remove&lowbar;const&lowbar;t`] 
| Alias for `std&colon;&colon;remove&lowbar;const&lt;T&gt;&colon;&colon;type`, provided for compilers that predate C&plus;&plus;14&apos;s `std&colon;&colon;remove&lowbar;const&lowbar;t`&period;
| xref:fmt/remove_cvref_t.adoc[`remove&lowbar;cvref&lowbar;t`] 
| Alias for `std&colon;&colon;remove&lowbar;cv&lt;std&colon;&colon;remove&lowbar;reference&lt;T&gt;&colon;&colon;type&gt;&colon;&colon;type`, provided for compilers that predate C&plus;&plus;20&apos;s `std&colon;&colon;remove&lowbar;cvref&lowbar;t`&period;
| xref:fmt/remove_reference_t.adoc[`remove&lowbar;reference&lowbar;t`] 
| Alias for `std&colon;&colon;remove&lowbar;reference&lt;T&gt;&colon;&colon;type`, provided for compilers that predate C&plus;&plus;14&apos;s `std&colon;&colon;remove&lowbar;reference&lowbar;t`&period;
| xref:fmt/string_view.adoc[`string&lowbar;view`] 
| A `basic&lowbar;string&lowbar;view` specialized for `char`&period;
| xref:fmt/sys_time.adoc[`sys&lowbar;time`] 
| A time point on the system clock, with the given `Duration` resolution&period;
| xref:fmt/ullong.adoc[`ullong`] 
| Alias for `unsigned long long`&period;
| xref:fmt/underlying_t.adoc[`underlying&lowbar;t`] 
| Alias for `std&colon;&colon;underlying&lowbar;type&lt;T&gt;&colon;&colon;type`, provided for compilers that predate C&plus;&plus;14&apos;s `std&colon;&colon;underlying&lowbar;type&lowbar;t`&period;
| xref:fmt/utc_time.adoc[`utc&lowbar;time`] 
| A time point on the UTC clock, with the given `Duration` resolution&period;
| xref:fmt/vargs.adoc[`vargs`] 
| The type returned by `make&lowbar;format&lowbar;args` for the default `context`&period;
| xref:fmt/void_t.adoc[`void&lowbar;t`] 
| Alias that maps any set of types to `void`, used to detect the validity of an expression in SFINAE contexts&period;
| xref:fmt/wcstring_view.adoc[`wcstring&lowbar;view`] 
| A `basic&lowbar;cstring&lowbar;view` for `wchar&lowbar;t` strings&period;
| xref:fmt/weekday.adoc[`weekday`] 
| 
| xref:fmt/wformat_args.adoc[`wformat&lowbar;args`] 
| A `wchar&lowbar;t` counterpart of `format&lowbar;args`&period;
| xref:fmt/wformat_context.adoc[`wformat&lowbar;context`] 
| A `wchar&lowbar;t` counterpart of `context`&period;
| xref:fmt/wformat_parse_context.adoc[`wformat&lowbar;parse&lowbar;context`] 
| A `wchar&lowbar;t` counterpart of `format&lowbar;parse&lowbar;context`&period;
| xref:fmt/wformat_string.adoc[`wformat&lowbar;string`] 
| A `wchar&lowbar;t` counterpart of `format&lowbar;string`&period;
| xref:fmt/wmemory_buffer.adoc[`wmemory&lowbar;buffer`] 
| A `wchar&lowbar;t` counterpart of `memory&lowbar;buffer`&period;
| xref:fmt/wprintf_args.adoc[`wprintf&lowbar;args`] 
| The type&hyphen;erased argument list used with `wprintf&lowbar;context`&period;
| xref:fmt/wprintf_context.adoc[`wprintf&lowbar;context`] 
| A `basic&lowbar;printf&lowbar;context` for `wchar&lowbar;t` strings&period;
| xref:fmt/wstring_view.adoc[`wstring&lowbar;view`] 
| A `wchar&lowbar;t` counterpart of `string&lowbar;view`&period;
| xref:fmt/year.adoc[`year`] 
| 
| xref:fmt/year_month_day.adoc[`year&lowbar;month&lowbar;day`] 
| 
|===


=== Enums

[cols="1,4"]
|===
| Name| Description
| xref:fmt/_04enum.adoc[`Unnamed enum`] 
| The number of characters to store in the basic&lowbar;memory&lowbar;buffer object itself to avoid dynamic memory allocation&period;
| xref:fmt/align.adoc[`align`] 
| The alignment of a formatted value within its field width&period;
| xref:fmt/arg_id_kind.adoc[`arg&lowbar;id&lowbar;kind`] 
| The kind of dynamic argument, if any, used to supply a field width or precision&period;
| xref:fmt/color.adoc[`color`] 
| A named color from the extended CSS&sol;X11 color set, encoded as a packed 0xRRGGBB value&period;
| xref:fmt/emphasis.adoc[`emphasis`] 
| A bitmask of text emphasis styles that can be combined with `operator&verbar;`&period;
| xref:fmt/presentation_type.adoc[`presentation&lowbar;type`] 
| The presentation type of a format specifier, encoding which of the mutually exclusive type letters (e&period;g&period; &apos;d&apos;, &apos;x&apos;, &apos;f&apos;, &apos;s&apos;) was used&period; Enumerators for unrelated categories (integral&sol;character, string&sol;pointer, floating&hyphen;point) intentionally share numeric values because at most one category applies to a given argument type&period;
| xref:fmt/range_format.adoc[`range&lowbar;format`] 
| The style used to format a range or range&hyphen;like type&period;
| xref:fmt/sign.adoc[`sign`] 
| The sign specifier controlling how the sign of a numeric value is formatted&period;
| xref:fmt/terminal_color.adoc[`terminal&lowbar;color`] 
| Terminal colors that map to the standard ANSI SGR foreground color codes&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:fmt/arg-0e.adoc[`arg`] 
| `arg` overloads
| xref:fmt/assert_fail.adoc[`assert&lowbar;fail`]  [.small]#[noreturn]#
| Reports an assertion failure, used by the `FMT&lowbar;ASSERT` macro when `condition` evaluates to false&period;
| xref:fmt/bg.adoc[`bg`] 
| Creates a text style from the background color&period;
| xref:fmt/fg.adoc[`fg`] 
| Creates a text style from the foreground (text) color&period;
| xref:fmt/format-021.adoc[`format`] 
| `format` overloads
| xref:fmt/format_system_error.adoc[`format&lowbar;system&lowbar;error`] 
| Formats an error message for an error returned by an operating system or a language runtime, for example a file opening error, and writes it to `out`&period; The format is the same as the one used by `std&colon;&colon;system&lowbar;error(ec, message)` where `ec` is `std&colon;&colon;error&lowbar;code(error&lowbar;code, std&colon;&colon;generic&lowbar;category())`&period; It is implementation&hyphen;defined but normally looks like&colon;
| xref:fmt/format_to-0da.adoc[`format&lowbar;to`] 
| `format&lowbar;to` overloads
| xref:fmt/format_to_n-0b.adoc[`format&lowbar;to&lowbar;n`] 
| `format&lowbar;to&lowbar;n` overloads
| xref:fmt/formatted_size-0e.adoc[`formatted&lowbar;size`] 
| `formatted&lowbar;size` overloads
| xref:fmt/fprintf-0b.adoc[`fprintf`] 
| `fprintf` overloads
| xref:fmt/gmtime-03.adoc[`gmtime`] 
| `gmtime` overloads
| xref:fmt/group_digits.adoc[`group&lowbar;digits`] 
| Returns a view that formats an integer value using &apos;,&apos; as a locale&hyphen;independent thousands separator&period;
| xref:fmt/join-03.adoc[`join`] 
| `join` overloads
| xref:fmt/make_format_args.adoc[`make&lowbar;format&lowbar;args`] 
| Constructs an object that stores references to arguments and can be implicitly converted to `format&lowbar;args`&period; `Context` can be omitted in which case it defaults to `context`&period; See `arg` for lifetime considerations&period;
| xref:fmt/make_printf_args.adoc[`make&lowbar;printf&lowbar;args`] 
| Constructs an `format&lowbar;arg&lowbar;store` object that contains references to arguments and can be implicitly converted to `printf&lowbar;args`&period;
| xref:fmt/make_wformat_args.adoc[`make&lowbar;wformat&lowbar;args`] 
| A `wchar&lowbar;t` counterpart of `make&lowbar;format&lowbar;args`&period;
| xref:fmt/max_of.adoc[`max&lowbar;of`] 
| Returns the larger of `a` and `b`&period;
| xref:fmt/min_of.adoc[`min&lowbar;of`] 
| Returns the smaller of `a` and `b`&period;
| xref:fmt/operator_a.adoc[`operator&quot;&quot;&lowbar;a`] 
| User&hyphen;defined literal equivalent of `fmt&colon;&colon;arg`, but with compile&hyphen;time checks&period;
| xref:fmt/operator_cf.adoc[`operator&quot;&quot;&lowbar;cf`] 
| Converts a string literal into a format string that will be parsed at compile time and converted into efficient formatting code&period; Requires support for class types in constant template parameters (a C&plus;&plus;20 feature)&period;
| xref:fmt/operator_bitor-08.adoc[`operator&verbar;`] 
| Bitwise disjunction operators
| xref:fmt/print-02c.adoc[`print`] 
| `print` overloads
| xref:fmt/printf.adoc[`printf`] 
| Formats `args` according to specifications in `fmt` and writes the output to `stdout`&period;
| xref:fmt/println-0d.adoc[`println`] 
| `println` overloads
| xref:fmt/ptr-06.adoc[`ptr`] 
| `ptr` overloads
| xref:fmt/report_error.adoc[`report&lowbar;error`]  [.small]#[noreturn]#
| Reports a format error at compile time or, via a `format&lowbar;error` exception, at runtime&period;
| xref:fmt/report_system_error.adoc[`report&lowbar;system&lowbar;error`] 
| Reports a system error without throwing an exception&period; Can be used to report errors from destructors&period;
| xref:fmt/runtime-0c3.adoc[`runtime`] 
| `runtime` overloads
| xref:fmt/sprintf-05.adoc[`sprintf`] 
| `sprintf` overloads
| xref:fmt/streamed.adoc[`streamed`] 
| Returns a view that formats `value` via an ostream `operator&lt;&lt;`&period;
| xref:fmt/styled.adoc[`styled`] 
| Returns an argument that will be formatted using ANSI escape sequences, to be used in a formatting function&period;
| xref:fmt/system_category.adoc[`system&lowbar;category`] 
| Returns the system error category used to construct `std&colon;&colon;system&lowbar;error` objects on non&hyphen;Windows platforms&period;
| xref:fmt/system_error.adoc[`system&lowbar;error`] 
| Constructs `std&colon;&colon;system&lowbar;error` with a message formatted with `fmt&colon;&colon;format(fmt, args&period;&period;&period;)`&period; `error&lowbar;code` is a system error code as given by `errno`&period;
| xref:fmt/to_string-0b.adoc[`to&lowbar;string`] 
| `to&lowbar;string` overloads
| xref:fmt/to_wstring.adoc[`to&lowbar;wstring`] 
| Converts `value` to `std&colon;&colon;wstring` using the default format for type `T`&period;
| xref:fmt/underlying.adoc[`underlying`] 
| Converts `e` to the underlying type&period;
| xref:fmt/vformat-02.adoc[`vformat`] 
| `vformat` overloads
| xref:fmt/vformat_to-0b.adoc[`vformat&lowbar;to`] 
| `vformat&lowbar;to` overloads
| xref:fmt/vformat_to_n-01.adoc[`vformat&lowbar;to&lowbar;n`] 
| `vformat&lowbar;to&lowbar;n` overloads
| xref:fmt/vfprintf.adoc[`vfprintf`] 
| Formats `args` according to specifications in `fmt` and writes the output to the file `f`&period;
| xref:fmt/vprint-00.adoc[`vprint`] 
| `vprint` overloads
| xref:fmt/vprint_buffered.adoc[`vprint&lowbar;buffered`] 
| Formats `args` according to specifications in `fmt` into a buffer and writes the buffer to the file `f` in a single write&period;
| xref:fmt/vprintln-08d.adoc[`vprintln`] 
| `vprintln` overloads
| xref:fmt/vsprintf.adoc[`vsprintf`] 
| Formats `args` according to specifications in `fmt` and returns the result as a string&period;
| xref:fmt/vsystem_error.adoc[`vsystem&lowbar;error`] 
| Constructs `std&colon;&colon;system&lowbar;error` with a message formatted with `fmt&colon;&colon;vformat(fmt, args)`&period;
| xref:fmt/operator_eq.adoc[`operator&equals;&equals;`] 
| `true` if `lhs` and `rhs` are equal&period;
| xref:fmt/operator_not_eq.adoc[`operator!&equals;`] 
| `true` if `lhs` and `rhs` are not equal&period;
| xref:fmt/operator_lt.adoc[`operator&lt;`] 
| `true` if `lhs` is lexicographically less than `rhs`&period;
| xref:fmt/operator_le.adoc[`operator&lt;&equals;`] 
| `true` if `lhs` is lexicographically less than or equal to&period;
| xref:fmt/operator_gt.adoc[`operator&gt;`] 
| `true` if `lhs` is lexicographically greater than `rhs`&period;
| xref:fmt/operator_ge.adoc[`operator&gt;&equals;`] 
| `true` if `lhs` is lexicographically greater than or equal to&period;
|===


=== Concepts

[cols="1,4"]
|===
| Name| Description
| xref:fmt/formattable.adoc[`formattable`] 
| A concept satisfied by types that can be formatted with character type `Char`&period;
|===


== xref:fmt/enums.adoc[fmt::enums] namespace

Contains `format&lowbar;as` overloads that make enum types formattable by converting them to their underlying type&period;

=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:fmt/enums/format_as.adoc[`format&lowbar;as`] 
| Converts `e` to its underlying type so that enum types are formattable by default via argument&hyphen;dependent lookup&period;
|===


== xref:fmt/safe_duration_cast.adoc[fmt::safe&lowbar;duration&lowbar;cast] namespace

Helpers for converting between `std&colon;&colon;chrono&colon;&colon;duration` types without undefined behavior or erroneous results due to overflow&period;

=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:fmt/safe_duration_cast/lossless_integral_conversion-0f.adoc[`lossless&lowbar;integral&lowbar;conversion`] 
| `lossless&lowbar;integral&lowbar;conversion` overloads
| xref:fmt/safe_duration_cast/safe_duration_cast.adoc[`safe&lowbar;duration&lowbar;cast`] 
| Safe duration&lowbar;cast between floating point durations
| xref:fmt/safe_duration_cast/safe_float_conversion-03.adoc[`safe&lowbar;float&lowbar;conversion`] 
| `safe&lowbar;float&lowbar;conversion` overloads
|===



[.small]#Created with https://www.mrdocs.com[MrDocs]#
