Reference

Namespaces

Name
`fmt`

fmt namespace

Namespaces

Name
`enums`
`safe_duration_cast`

Types

Name	Description
`basic_appender`
`basic_cstring_view`	A reference to a null-terminated string. It can be constructed from a C string or `std::string`.
`basic_format_arg`
`basic_format_args`	A view of a collection of formatting arguments. To avoid lifetime issues it should only be used as a parameter type in type-erased functions such as `vformat`:
`basic_fstring`
`basic_memory_buffer`	A dynamically growing memory buffer for trivially copyable/constructible types with the first `SIZE` elements stored in the object itself. Most commonly used via the `memory_buffer` alias for `char`.
`basic_ostream_formatter`
`basic_printf_context`
`basic_specs`
`basic_string_view`	An implementation of `std::basic_string_view` for pre-C++17 providing a subset of the API. `fmt::basic_string_view` is used in the public API even if `std::basic_string_view` is available to prevent issues when a library is compiled with a different `-std` option than the client code (which is not recommended).
`buffered_file`
`bytes`
`compiled_string`
`conjunction`
`conjunction<P>`
`conjunction<P1, Pn...>`
`context`
`dynamic_format_arg_store`	A dynamic list of formatting arguments with storage.
`file`
`format_error`	An error reported from a formatting function.
`format_facet`
`format_facet<locale>`
`format_int`	A fast integer formatter.
`format_specs`
`format_to_n_result`
`format_to_result`
`formatter`
`formatter</* implementation-defined */>`
`formatter<bytes>`
`formatter<std::error_code>`
`formatter<std::source_location>`
`formatter<std::type_info>`
`formatter<group_digits_view<T>>`
`formatter<T, char>`
`formatter<std::atomic_flag, Char>`
`formatter<std::byte, Char>`
`formatter<day, Char>`
`formatter</* implementation-defined */, Char>`
`formatter<std::thread::id, Char>`
`formatter<long, Char>`
`formatter<std::monostate, Char>`
`formatter<month, Char>`
`formatter<std::nullptr_t, Char>`
`formatter<std::filesystem::path, Char>`
`formatter<short, Char>`
`formatter<signed char, Char>`
`formatter<tm, Char>`
`formatter<unsigned char, Char>`
`formatter<unsigned long, Char>`
`formatter<unsigned short, Char>`
`formatter<weekday, Char>`
`formatter<year, Char>`
`formatter<year_month_day, Char>`
`formatter</* implementation-defined */, Char>`
`formatter<Char*, Char>`
`formatter<void*, Char>`
`formatter<BitRef, Char>`
`formatter<R, Char>`
`formatter<R, Char>`
`formatter<R, Char>`
`formatter<T, Char>`
`formatter<T, Char>`
`formatter<Tuple, Char>`
`formatter<Variant, Char>`
`formatter<std::atomic<T>, Char>`
`formatter<std::bitset<N>, Char>`
`formatter<std::complex<T>, Char>`
`formatter<local_time<Duration>, Char>`
`formatter<nested_view<T, Char>, Char>`
`formatter<std::optional<T>, Char>`
`formatter<std::reference_wrapper<T>, Char>`
`formatter</* implementation-defined */, Char>`
`formatter</* implementation-defined */, Char>`
`formatter<sys_time<Duration>, Char>`
`formatter<tuple_join_view<Tuple, Char>, Char>`
`formatter</* implementation-defined */, Char>`
`formatter<std::unexpected<E>, Char>`
`formatter<utc_time<Duration>, Char>`
`formatter<Char[N], Char>`
`formatter<std::basic_string<Char, Traits, Allocator>, Char>`
`formatter<std::chrono::duration<Rep, Period>, Char>`
`formatter<std::expected<T, E>, Char>`
`formatter<join_view<It, Sentinel, Char>, Char>`
`formatter<T, Char, void_t</* implementation-defined */>>`
`fstring`	A compile-time format string. Use `format_string` in the public API to prevent type deduction.
`generic_context`
`group_digits_view`
`is_compiled_string`
`is_container_adaptor`	Specifies if `T` is a container adaptor (like `std::stack`) that should be formatted as the underlying container.
`is_contiguous`
`is_contiguous<basic_memory_buffer<T, SIZE, Allocator>>`
`is_contiguous<std::basic_string<Char, Traits, Allocator>>`
`is_range`
`is_tuple_formattable`
`is_tuple_like`
`is_tuple_like<std::complex<T>>`
`is_variant_like`
`join_view`
`loc_value`
`locale_ref`
`locking`
`monostate`
`nested_formatter`
`nested_view`
`parse_context`	Parsing context consisting of a format string range being parsed and an argument counter for automatic indexing.
`parse_context<char>`
`path`
`range_format_kind`
`range_formatter`
`range_formatter<T, Char>`
`rgb`
`runtime_format_string`
`static_format_result`
`string_buffer`
`text_style`	A text style consisting of foreground and background colors and emphasis.
`tuple_join_view`
`vprintf_args`
`writer`

Type Aliases

Name
`appender`
`basic_format_context`
`basic_format_parse_context`
`basic_format_string`
`bool_constant`
`buffered_context`
`conditional_t`
`cstring_view`
`day`
`decay_t`
`enable_if_t`
`format_args`
`format_context`
`format_parse_context`
`format_string`
`is_formattable`
`local_time`
`make_unsigned_t`
`memory_buffer`
`month`
`named_arg`
`nullptr_t`
`ostream_formatter`
`printf_args`
`printf_context`
`remove_const_t`
`remove_cvref_t`
`remove_reference_t`
`string_view`
`sys_time`
`ullong`
`underlying_t`
`utc_time`
`vargs`
`void_t`
`wcstring_view`
`weekday`
`wformat_args`
`wformat_context`
`wformat_parse_context`
`wformat_string`
`wmemory_buffer`
`wprintf_args`
`wprintf_context`
`wstring_view`
`year`
`year_month_day`

Enums

Name
`Unnamed enum`
`align`
`arg_id_kind`
`color`
`emphasis`
`presentation_type`
`range_format`
`sign`
`terminal_color`

Functions

Name	Description
`Unnamed overloads`	User-defined literal equivalent of `fmt::arg`, but with compile-time checks.
`arg`	Returns a named argument to be used in a formatting function. It should only be used in a call to a formatting function.
`assert_fail`
`bg`	Creates a text style from the background color.
`fg`	Creates a text style from the foreground (text) color.
`format`	`format` overloads
`format_system_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`. The format is the same as the one used by `std::system_error(ec, message)` where `ec` is `std::error_code(error_code, std::generic_category())`. It is implementation-defined but normally looks like:
`format_to`	`format_to` overloads
`format_to_n`	Formats `args` according to specifications in `fmt`, writes up to `n` characters of the result to the output iterator `out` and returns the total (not truncated) output size and the iterator past the end of the output range. `format_to_n` does not append a terminating null character.
`formatted_size`	Returns the number of chars in the output of `format(fmt, args...)`.
`fprintf`	Formats `args` according to specifications in `fmt` and writes the output to `f`.
`gmtime`	Converts given time since epoch as `std::time_t` value into calendar time, expressed in Coordinated Universal Time (UTC). Unlike `std::gmtime`, this function is thread-safe on most platforms.
`group_digits`	Returns a view that formats an integer value using ',' as a locale-independent thousands separator.
`join`	`join` overloads
`make_format_args`
`make_printf_args`	Constructs an `format_arg_store` object that contains references to arguments and can be implicitly converted to `printf_args`.
`make_wformat_args`
`max_of`
`min_of`
`operator\|`	Bitwise disjunction operators
`print`	`print` overloads
`printf`	Formats `args` according to specifications in `fmt` and writes the output to `stdout`.
`println`	`println` overloads
`ptr`	Converts `p` to `const void*` for pointer formatting.
`report_error`	Reports a format error at compile time or, via a `format_error` exception, at runtime.
`report_system_error`
`runtime`	Creates a runtime format string.
`sprintf`	Formats `args` according to specifications in `fmt` and returns the result as string.
`streamed`	Returns a view that formats `value` via an ostream `operator<<`.
`styled`	Returns an argument that will be formatted using ANSI escape sequences, to be used in a formatting function.
`system_category`
`system_error`	Constructs `std::system_error` with a message formatted with `fmt::format(fmt, args...)`. `error_code` is a system error code as given by `errno`.
`to_string`	Converts `value` to `std::string` using the default format for type `T`.
`to_wstring`	Converts `value` to `std::wstring` using the default format for type `T`.
`underlying`	Converts `e` to the underlying type.
`vformat`
`vformat_to`	`vformat_to` overloads
`vformat_to_n`
`vfprintf`
`vprint`
`vprint_buffered`
`vprintln`
`vsprintf`
`vsystem_error`
`operator==`	Equality operator
`operator!=`	Inequality operator
`operator<`	Less-than operator
`operator<=`	Less-than-or-equal operator
`operator>`	Greater-than operator
`operator>=`	Greater-than-or-equal operator

Concepts

Name
`formattable`

fmt::enums namespace

Functions

Name
`format_as`

fmt::safe_duration_cast namespace

Functions

Name	Description
`lossless_integral_conversion`	Converts From to To, without loss. If the dynamic value of from can't be converted to To without loss, ec is set.
`safe_duration_cast`	Safe duration_cast between floating point durations
`safe_float_conversion`	converts From to To if possible, otherwise ec is set.

Namespaces

Name
`enums`
`safe_duration_cast`

Types

Name	Description
`basic_appender`
`basic_cstring_view`	A reference to a null-terminated string. It can be constructed from a C string or `std::string`.
`basic_format_arg`
`basic_format_args`	A view of a collection of formatting arguments. To avoid lifetime issues it should only be used as a parameter type in type-erased functions such as `vformat`:
`basic_fstring`
`basic_memory_buffer`	A dynamically growing memory buffer for trivially copyable/constructible types with the first `SIZE` elements stored in the object itself. Most commonly used via the `memory_buffer` alias for `char`.
`basic_ostream_formatter`
`basic_printf_context`
`basic_specs`
`basic_string_view`	An implementation of `std::basic_string_view` for pre-C++17 providing a subset of the API. `fmt::basic_string_view` is used in the public API even if `std::basic_string_view` is available to prevent issues when a library is compiled with a different `-std` option than the client code (which is not recommended).
`buffered_file`
`bytes`
`compiled_string`
`conjunction`
`conjunction<P>`
`conjunction<P1, Pn...>`
`context`
`dynamic_format_arg_store`	A dynamic list of formatting arguments with storage.
`file`
`format_error`	An error reported from a formatting function.
`format_facet`
`format_facet<locale>`
`format_int`	A fast integer formatter.
`format_specs`
`format_to_n_result`
`format_to_result`
`formatter`
`formatter</* implementation-defined */>`
`formatter<bytes>`
`formatter<std::error_code>`
`formatter<std::source_location>`
`formatter<std::type_info>`
`formatter<group_digits_view<T>>`
`formatter<T, char>`
`formatter<std::atomic_flag, Char>`
`formatter<std::byte, Char>`
`formatter<day, Char>`
`formatter</* implementation-defined */, Char>`
`formatter<std::thread::id, Char>`
`formatter<long, Char>`
`formatter<std::monostate, Char>`
`formatter<month, Char>`
`formatter<std::nullptr_t, Char>`
`formatter<std::filesystem::path, Char>`
`formatter<short, Char>`
`formatter<signed char, Char>`
`formatter<tm, Char>`
`formatter<unsigned char, Char>`
`formatter<unsigned long, Char>`
`formatter<unsigned short, Char>`
`formatter<weekday, Char>`
`formatter<year, Char>`
`formatter<year_month_day, Char>`
`formatter</* implementation-defined */, Char>`
`formatter<Char*, Char>`
`formatter<void*, Char>`
`formatter<BitRef, Char>`
`formatter<R, Char>`
`formatter<R, Char>`
`formatter<R, Char>`
`formatter<T, Char>`
`formatter<T, Char>`
`formatter<Tuple, Char>`
`formatter<Variant, Char>`
`formatter<std::atomic<T>, Char>`
`formatter<std::bitset<N>, Char>`
`formatter<std::complex<T>, Char>`
`formatter<local_time<Duration>, Char>`
`formatter<nested_view<T, Char>, Char>`
`formatter<std::optional<T>, Char>`
`formatter<std::reference_wrapper<T>, Char>`
`formatter</* implementation-defined */, Char>`
`formatter</* implementation-defined */, Char>`
`formatter<sys_time<Duration>, Char>`
`formatter<tuple_join_view<Tuple, Char>, Char>`
`formatter</* implementation-defined */, Char>`
`formatter<std::unexpected<E>, Char>`
`formatter<utc_time<Duration>, Char>`
`formatter<Char[N], Char>`
`formatter<std::basic_string<Char, Traits, Allocator>, Char>`
`formatter<std::chrono::duration<Rep, Period>, Char>`
`formatter<std::expected<T, E>, Char>`
`formatter<join_view<It, Sentinel, Char>, Char>`
`formatter<T, Char, void_t</* implementation-defined */>>`
`fstring`	A compile-time format string. Use `format_string` in the public API to prevent type deduction.
`generic_context`
`group_digits_view`
`is_compiled_string`
`is_container_adaptor`	Specifies if `T` is a container adaptor (like `std::stack`) that should be formatted as the underlying container.
`is_contiguous`
`is_contiguous<basic_memory_buffer<T, SIZE, Allocator>>`
`is_contiguous<std::basic_string<Char, Traits, Allocator>>`
`is_range`
`is_tuple_formattable`
`is_tuple_like`
`is_tuple_like<std::complex<T>>`
`is_variant_like`
`join_view`
`loc_value`
`locale_ref`
`locking`
`monostate`
`nested_formatter`
`nested_view`
`parse_context`	Parsing context consisting of a format string range being parsed and an argument counter for automatic indexing.
`parse_context<char>`
`path`
`range_format_kind`
`range_formatter`
`range_formatter<T, Char>`
`rgb`
`runtime_format_string`
`static_format_result`
`string_buffer`
`text_style`	A text style consisting of foreground and background colors and emphasis.
`tuple_join_view`
`vprintf_args`
`writer`

Type Aliases

Name
`appender`
`basic_format_context`
`basic_format_parse_context`
`basic_format_string`
`bool_constant`
`buffered_context`
`conditional_t`
`cstring_view`
`day`
`decay_t`
`enable_if_t`
`format_args`
`format_context`
`format_parse_context`
`format_string`
`is_formattable`
`local_time`
`make_unsigned_t`
`memory_buffer`
`month`
`named_arg`
`nullptr_t`
`ostream_formatter`
`printf_args`
`printf_context`
`remove_const_t`
`remove_cvref_t`
`remove_reference_t`
`string_view`
`sys_time`
`ullong`
`underlying_t`
`utc_time`
`vargs`
`void_t`
`wcstring_view`
`weekday`
`wformat_args`
`wformat_context`
`wformat_parse_context`
`wformat_string`
`wmemory_buffer`
`wprintf_args`
`wprintf_context`
`wstring_view`
`year`
`year_month_day`

Enums

Name
`Unnamed enum`
`align`
`arg_id_kind`
`color`
`emphasis`
`presentation_type`
`range_format`
`sign`
`terminal_color`

Functions

Name	Description
`Unnamed overloads`	User-defined literal equivalent of `fmt::arg`, but with compile-time checks.
`arg`	Returns a named argument to be used in a formatting function. It should only be used in a call to a formatting function.
`assert_fail`
`bg`	Creates a text style from the background color.
`fg`	Creates a text style from the foreground (text) color.
`format`	`format` overloads
`format_system_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`. The format is the same as the one used by `std::system_error(ec, message)` where `ec` is `std::error_code(error_code, std::generic_category())`. It is implementation-defined but normally looks like:
`format_to`	`format_to` overloads
`format_to_n`	Formats `args` according to specifications in `fmt`, writes up to `n` characters of the result to the output iterator `out` and returns the total (not truncated) output size and the iterator past the end of the output range. `format_to_n` does not append a terminating null character.
`formatted_size`	Returns the number of chars in the output of `format(fmt, args...)`.
`fprintf`	Formats `args` according to specifications in `fmt` and writes the output to `f`.
`gmtime`	Converts given time since epoch as `std::time_t` value into calendar time, expressed in Coordinated Universal Time (UTC). Unlike `std::gmtime`, this function is thread-safe on most platforms.
`group_digits`	Returns a view that formats an integer value using ',' as a locale-independent thousands separator.
`join`	`join` overloads
`make_format_args`
`make_printf_args`	Constructs an `format_arg_store` object that contains references to arguments and can be implicitly converted to `printf_args`.
`make_wformat_args`
`max_of`
`min_of`
`operator\|`	Bitwise disjunction operators
`print`	`print` overloads
`printf`	Formats `args` according to specifications in `fmt` and writes the output to `stdout`.
`println`	`println` overloads
`ptr`	Converts `p` to `const void*` for pointer formatting.
`report_error`	Reports a format error at compile time or, via a `format_error` exception, at runtime.
`report_system_error`
`runtime`	Creates a runtime format string.
`sprintf`	Formats `args` according to specifications in `fmt` and returns the result as string.
`streamed`	Returns a view that formats `value` via an ostream `operator<<`.
`styled`	Returns an argument that will be formatted using ANSI escape sequences, to be used in a formatting function.
`system_category`
`system_error`	Constructs `std::system_error` with a message formatted with `fmt::format(fmt, args...)`. `error_code` is a system error code as given by `errno`.
`to_string`	Converts `value` to `std::string` using the default format for type `T`.
`to_wstring`	Converts `value` to `std::wstring` using the default format for type `T`.
`underlying`	Converts `e` to the underlying type.
`vformat`
`vformat_to`	`vformat_to` overloads
`vformat_to_n`
`vfprintf`
`vprint`
`vprint_buffered`
`vprintln`
`vsprintf`
`vsystem_error`
`operator==`	Equality operator
`operator!=`	Inequality operator
`operator<`	Less-than operator
`operator<=`	Less-than-or-equal operator
`operator>`	Greater-than operator
`operator>=`	Greater-than-or-equal operator

Concepts

Name
`formattable`

Functions

Name
`format_as`

Synopsis

Declared in <fmt/format.h>

template<typename Enum>
constexpr
underlying_t<Enum>
format_as(Enum e) noexcept;

Functions

Name	Description
`lossless_integral_conversion`	Converts From to To, without loss. If the dynamic value of from can't be converted to To without loss, ec is set.
`safe_duration_cast`	Safe duration_cast between floating point durations
`safe_float_conversion`	converts From to To if possible, otherwise ec is set.

Synopses

Declared in <fmt/chrono.h>

template<
    typename To,
    typename From>
constexpr
To
lossless_integral_conversion(
    From const from,
    int& ec);

» more...

Converts From to To, without loss. If the dynamic value of from can't be converted to To without loss, ec is set.

template<
    typename To,
    typename From>
constexpr
To
lossless_integral_conversion(
    From const from,
    int& ec);

» more...

template<
    typename To,
    typename From>
constexpr
To
lossless_integral_conversion(
    From const from,
    int& ec);

» more...

Synopsis

Declared in <fmt/chrono.h>

template<
    typename To,
    typename From>
constexpr
To
lossless_integral_conversion(
    From const from,
    int& ec);

Synopsis

Declared in <fmt/chrono.h>

template<
    typename To,
    typename From>
constexpr
To
lossless_integral_conversion(
    From const from,
    int& ec);

Synopsis

Declared in <fmt/chrono.h>

template<
    typename To,
    typename From>
constexpr
To
lossless_integral_conversion(
    From const from,
    int& ec);

Synopsis

Declared in <fmt/chrono.h>

template<
    typename To,
    typename FromRep,
    typename FromPeriod>
To
safe_duration_cast(
    std::chrono::duration<FromRep, FromPeriod> from,
    int& ec);

Synopses

Declared in <fmt/chrono.h>

converts From to To if possible, otherwise ec is set.

template<
    typename To,
    typename From>
constexpr
To
safe_float_conversion(
    From const from,
    int& ec);

» more...

template<
    typename To,
    typename From>
constexpr
To
safe_float_conversion(
    From const from,
    int& ec);

» more...

Synopsis

Declared in <fmt/chrono.h>

template<
    typename To,
    typename From>
constexpr
To
safe_float_conversion(
    From const from,
    int& ec);

Description

input | output ---------------------------------|--------------- NaN | NaN Inf | Inf normal, fits in output | converted (possibly lossy) normal, does not fit in output | ec is set subnormal | best effort -Inf | -Inf

Synopsis

Declared in <fmt/chrono.h>

template<
    typename To,
    typename From>
constexpr
To
safe_float_conversion(
    From const from,
    int& ec);

Synopsis

Declared in <fmt/base.h>

using appender = basic_appender<char>;

Synopsis

Declared in <fmt/base.h>

template<
    typename OutputIt,
    typename Char>
using basic_format_context = conditional_t<std::is_same<OutputIt, appender>::value, context, generic_context<OutputIt, Char>>;

Synopsis

Declared in <fmt/base.h>

template<typename Char>
using basic_format_parse_context = parse_context<Char>;

Synopsis

Declared in <fmt/xchar.h>

template<
    typename Char,
    typename... T>
using basic_format_string = basic_fstring<Char, T...>;

Synopsis

Declared in <fmt/base.h>

template<bool B>
using bool_constant = std::integral_constant<bool, B>;

Synopsis

Declared in <fmt/base.h>

template<typename Char>
using buffered_context = conditional_t<std::is_same<Char, char>::value, context, generic_context<basic_appender<Char>, Char>>;

Synopsis

Declared in <fmt/base.h>

template<
    bool B,
    typename T,
    typename F>
using conditional_t = std::conditional<B, T, F>::type;

Synopsis

Declared in <fmt/os.h>

using cstring_view = basic_cstring_view<char>;

Synopsis

Declared in <fmt/chrono.h>

using day = std::chrono::day;

Synopsis

Declared in <fmt/base.h>

template<typename T>
using decay_t = std::decay<T>::type;

Synopsis

Declared in <fmt/base.h>

template<
    bool B,
    typename T = void>
using enable_if_t = T;

Synopsis

Declared in <fmt/base.h>

using format_args = basic_format_args<context>;

Synopsis

Declared in <fmt/base.h>

using format_context = context;

Synopsis

Declared in <fmt/base.h>

using format_parse_context = parse_context<char>;

Synopsis

Declared in <fmt/base.h>

template<typename... T>
using format_string = fstring<T...>::t;

Synopsis

Declared in <fmt/base.h>

template<
    typename T,
    typename Char = char>
using is_formattable = bool_constant<!std::is_same<detail::mapped_t<conditional_t<std::is_void<T>::value, int *, T>, Char>, void>::value>;

Synopsis

Declared in <fmt/chrono.h>

template<class Duration>
using local_time = std::chrono::time_point</* implementation-defined */, Duration>;

Synopsis

Declared in <fmt/base.h>

template<typename T>
using make_unsigned_t = std::make_unsigned<T>::type;

Synopsis

Declared in <fmt/format.h>

using memory_buffer = basic_memory_buffer<char>;

Synopsis

Declared in <fmt/chrono.h>

using month = std::chrono::month;

Synopsis

Declared in <fmt/base.h>

template<
    typename T,
    typename Char = char>
using named_arg = /* implementation-defined */;

Synopsis

Declared in <fmt/base.h>

using nullptr_t = decltype(nullptr);

Synopsis

Declared in <fmt/ostream.h>

using ostream_formatter = basic_ostream_formatter<char>;

Synopsis

Declared in <fmt/printf.h>

using printf_args = basic_format_args<printf_context>;

Synopsis

Declared in <fmt/printf.h>

using printf_context = basic_printf_context<char>;

Synopsis

Declared in <fmt/base.h>

template<typename T>
using remove_const_t = std::remove_const<T>::type;

Synopsis

Declared in <fmt/base.h>

template<typename T>
using remove_cvref_t = std::remove_cv<remove_reference_t<T>>::type;

Synopsis

Declared in <fmt/base.h>

template<typename T>
using remove_reference_t = std::remove_reference<T>::type;

Synopsis

Declared in <fmt/base.h>

using string_view = basic_string_view<char>;

Synopsis

Declared in <fmt/chrono.h>

template<typename Duration>
using sys_time = std::chrono::time_point<std::chrono::system_clock, Duration>;

Synopsis

Declared in <fmt/base.h>

using ullong = unsigned long long;

Synopsis

Declared in <fmt/base.h>

template<typename T>
using underlying_t = std::underlying_type<T>::type;

Synopsis

Declared in <fmt/chrono.h>

template<typename Duration>
using utc_time = std::chrono::time_point</* implementation-defined */, Duration>;

Synopsis

Declared in <fmt/base.h>

template<typename... T>
using vargs = /* implementation-defined */;

Synopsis

Declared in <fmt/base.h>

template<typename...>
using void_t = void;

Synopsis

Declared in <fmt/os.h>

using wcstring_view = basic_cstring_view<wchar_t>;

Synopsis

Declared in <fmt/chrono.h>

using weekday = std::chrono::weekday;

Synopsis

Declared in <fmt/xchar.h>

using wformat_args = basic_format_args<wformat_context>;

Synopsis

Declared in <fmt/xchar.h>

using wformat_context = buffered_context<wchar_t>;

Synopsis

Declared in <fmt/xchar.h>

using wformat_parse_context = parse_context<wchar_t>;

Synopsis

Declared in <fmt/xchar.h>

template<typename... T>
using wformat_string = basic_format_string<wchar_t, T...>::t;

Synopsis

Declared in <fmt/xchar.h>

using wmemory_buffer = basic_memory_buffer<wchar_t>;

Synopsis

Declared in <fmt/printf.h>

using wprintf_args = basic_format_args<wprintf_context>;

Synopsis

Declared in <fmt/printf.h>

using wprintf_context = basic_printf_context<wchar_t>;

Synopsis

Declared in <fmt/xchar.h>

using wstring_view = basic_string_view<wchar_t>;

Synopsis

Declared in <fmt/chrono.h>

using year = std::chrono::year;

Synopsis

Declared in <fmt/chrono.h>

using year_month_day = std::chrono::year_month_day;

Synopsis

Declared in <fmt/base.h>

template<typename T>
class basic_appender;

Type Aliases

Name
`container_type`

Member Functions

Name	Description
`basic_appender` [constructor]	Construct from `buffer`
`operator=`	Assignment operator
`operator*`	Dereference operator
`operator++`	Increment operators

Protected Data Members

Name
`container`

Synopsis

Declared in <fmt/base.h>

using container_type = /* implementation-defined */;

Synopsis

Declared in <fmt/base.h>

constexpr
basic_appender(/* implementation-defined */& buf);

Parameters

Name	Description
buf	The object to copy construct from

Synopsis

Declared in <fmt/base.h>

constexpr
basic_appender&
operator=(T c);

Return Value

Reference to the current object

Parameters

Name	Description
c	The object to assign from

Synopsis

Declared in <fmt/base.h>

constexpr
basic_appender&
operator*();

Return Value

Reference to the current object

Synopses

Declared in <fmt/base.h>

Increment operator

constexpr
basic_appender&
operator++();

» more...

Increment operator

constexpr
basic_appender
operator++(int);

» more...

Synopsis

Declared in <fmt/base.h>

constexpr
basic_appender&
operator++();

Return Value

Reference to the current object

Synopsis

Declared in <fmt/base.h>

constexpr
basic_appender
operator++(int);

Return Value

Another instance of the object

Synopsis

Declared in <fmt/base.h>

/* implementation-defined */* container;

Synopsis

Declared in <fmt/os.h>

template<typename Char>
class basic_cstring_view;

Description

You can use one of the following type aliases for common character types:

This class is most useful as a parameter type for functions that wrap C APIs.

Member Functions

Name	Description
`basic_cstring_view` [constructor]	Constructors
`c_str`	Returns the pointer to a C string.

Synopses

Declared in <fmt/os.h>

Constructs a string reference from an std::string object.

basic_cstring_view(std::basic_string<Char> const& s);

» more...

Constructs a string reference object from a C string.

basic_cstring_view(Char const* s);

» more...

Synopsis

Declared in <fmt/os.h>

basic_cstring_view(std::basic_string<Char> const& s);

Parameters

Name	Description
s	The object to copy construct from

Synopsis

Declared in <fmt/os.h>

basic_cstring_view(Char const* s);

Parameters

Name	Description
s	The object to construct from

Synopsis

Declared in <fmt/os.h>

Char const*
c_str() const;

Return Value

the pointer to a C string.

Synopsis

Declared in <fmt/base.h>

template<typename Context>
class basic_format_arg;

Types

Name
`handle`

Member Functions

Name	Description
`basic_format_arg` [constructor]	Constructors
`format_custom`
`type`
`visit`	Visits an argument dispatching to the appropriate visit method based on the argument type. For example, if the argument type is `double` then `vis(value)` will be called with the value of type `double`.
`operator bool`	Conversion to `bool`

Friends

Name	Description
`fmt::basic_format_args`	A view of a collection of formatting arguments. To avoid lifetime issues it should only be used as a parameter type in type-erased functions such as `vformat`:

Synopsis

Declared in <fmt/base.h>

class handle;

Member Functions

Name	Description
`handle` [constructor]	Construct from `custom_value`
`format`

Synopsis

Declared in <fmt/base.h>

explicit
handle(/* implementation-defined */ custom);

Parameters

Name	Description
custom	The object to construct from

Synopsis

Declared in <fmt/base.h>

void
format(
    parse_context<char_type>& parse_ctx,
    Context& ctx) const;

Synopses

Declared in <fmt/base.h>

Default constructor

constexpr
basic_format_arg();

» more...

Construct from T

template<typename T>
basic_format_arg(T&& val);

» more...

basic_format_arg(
    /* implementation-defined */ const* args,
    size_t size);

» more...

Synopsis

Declared in <fmt/base.h>

constexpr
basic_format_arg();

Synopsis

Declared in <fmt/base.h>

template<typename T>
basic_format_arg(T&& val);

Parameters

Name	Description
val	The object to move construct from

Synopsis

Declared in <fmt/base.h>

basic_format_arg(
    /* implementation-defined */ const* args,
    size_t size);

Synopsis

Declared in <fmt/base.h>

bool
format_custom(
    char_type const* parse_begin,
    parse_context<char_type>& parse_ctx,
    Context& ctx);

Synopsis

Declared in <fmt/base.h>

/* implementation-defined */
type() const;

Synopsis

Declared in <fmt/base.h>

template<typename Visitor>
constexpr
decltype(vis(0))
visit(Visitor&& vis) const;

Synopsis

Declared in <fmt/base.h>

constexpr
explicit
operator bool() const noexcept;

Return Value

The object converted to bool

Synopsis

Declared in <fmt/base.h>

template<typename Context>
class basic_format_args;

Description

void vlog(fmt::string_view fmt, fmt::format_args args); // OK fmt::format_args args = fmt::make_format_args(); // Dangling reference

Type Aliases

Name
`format_arg`

Member Functions

Name	Description
`basic_format_args` [constructor]	Constructors
`get`	Returns the argument with the specified id.
`get_id`
`max_size`

Data Members

Name
`args_` [variant member]
`values_` [variant member]

Synopsis

Declared in <fmt/base.h>

using format_arg = basic_format_arg<Context>;

Synopses

Declared in <fmt/base.h>

Default constructor

constexpr
basic_format_args();

» more...

Constructs a basic_format_args object from format_arg_store.

template<
    int NUM_ARGS,
    int NUM_NAMED_ARGS,
    ullong DESC>
[[always_inline]]
constexpr
basic_format_args(store<NUM_ARGS, NUM_NAMED_ARGS, DESC> const& s);

» more...

Construct from store

template<
    int NUM_ARGS,
    int NUM_NAMED_ARGS,
    ullong DESC>
constexpr
basic_format_args(store<NUM_ARGS, NUM_NAMED_ARGS, DESC> const& s);

» more...

Constructs a basic_format_args object from a dynamic list of arguments.

constexpr
basic_format_args(
    format_arg const* args,
    int count,
    bool has_named = false);

» more...

Synopsis

Declared in <fmt/base.h>

constexpr
basic_format_args();

Synopsis

Declared in <fmt/base.h>

template<
    int NUM_ARGS,
    int NUM_NAMED_ARGS,
    ullong DESC>
[[always_inline]]
constexpr
basic_format_args(store<NUM_ARGS, NUM_NAMED_ARGS, DESC> const& s);

Parameters

Name	Description
s	The object to copy construct from

Synopsis

Declared in <fmt/base.h>

template<
    int NUM_ARGS,
    int NUM_NAMED_ARGS,
    ullong DESC>
constexpr
basic_format_args(store<NUM_ARGS, NUM_NAMED_ARGS, DESC> const& s);

Parameters

Name	Description
s	The object to copy construct from

Synopsis

Declared in <fmt/base.h>

constexpr
basic_format_args(
    format_arg const* args,
    int count,
    bool has_named = false);

Parameters

Name	Description
args	The object to construct from

Synopses

Declared in <fmt/base.h>

Returns the argument with the specified id.

constexpr
format_arg
get(int id) const;

» more...

template<typename Char>
format_arg
get(basic_string_view<Char> name) const;

» more...

Synopsis

Declared in <fmt/base.h>

constexpr
format_arg
get(int id) const;

Return Value

the argument with the specified id.

Synopsis

Declared in <fmt/base.h>

template<typename Char>
format_arg
get(basic_string_view<Char> name) const;

Synopsis

Declared in <fmt/base.h>

template<typename Char>
constexpr
int
get_id(basic_string_view<Char> name) const;

Synopsis

Declared in <fmt/base.h>

int
max_size() const;

Synopsis

Declared in <fmt/base.h>

basic_format_arg<Context> const* args_;

Synopsis

Declared in <fmt/base.h>

/* implementation-defined */ const* values_;

Synopsis

Declared in <fmt/xchar.h>

template<
    typename Char,
    typename... T>
struct basic_fstring;

Type Aliases

Name
`t`

Member Functions

Name	Description
`basic_fstring` [constructor]	Constructors
`get`
`operator basic_string_view<Char>`	Conversion to `basic_string_view`

Synopsis

Declared in <fmt/xchar.h>

using t = basic_fstring;

Synopses

Declared in <fmt/xchar.h>

Construct from runtime_format_string

basic_fstring(runtime_format_string<Char> fmt);

» more...

Construct from S

template<typename S>
[[always_inline]]
basic_fstring(S const& value);

» more...

Construct from S

template<typename S>
[[always_inline]]
consteval
basic_fstring(S const& s);

» more...

Synopsis

Declared in <fmt/xchar.h>

basic_fstring(runtime_format_string<Char> fmt);

Parameters

Name	Description
fmt	The object to construct from

Synopsis

Declared in <fmt/xchar.h>

template<typename S>
[[always_inline]]
basic_fstring(S const& value);

Parameters

Name	Description
value	The object to copy construct from

Synopsis

Declared in <fmt/xchar.h>

template<typename S>
[[always_inline]]
consteval
basic_fstring(S const& s);

Parameters

Name	Description
s	The object to copy construct from

Synopsis

Declared in <fmt/xchar.h>

basic_string_view<Char>
get() const;

Synopsis

Declared in <fmt/xchar.h>

[[deprecated]]
operator basic_string_view<Char>() const;

Return Value

An implementation of std::basic_string_view for pre-C++17 providing a subset of the API. fmt::basic_string_view is used in the public API even if std::basic_string_view is available to prevent issues when a library is compiled with a different -std option than the client code (which is not recommended).

Synopsis

Declared in <fmt/format.h>

template<
    typename T,
    size_t SIZE = inline_buffer_size,
    typename Allocator = /* implementation-defined */>
class basic_memory_buffer
    : public /* implementation-defined */

Description

Example:

auto out = fmt::memory_buffer(); fmt::format_to(std::back_inserter(out), "The answer is {}.", 42);

This will append "The answer is 42." to out. The buffer content can be converted to std::string with to_string(out).

Base Classes

Name	Description
`/* implementation-defined */`	A contiguous memory buffer with an optional growing ability. It is an internal class and shouldn't be used directly, only via `memory_buffer`.

Type Aliases

Name
`const_reference`
`value_type`

Member Functions

Name	Description
`basic_memory_buffer` [constructor]	Constructs a `basic_memory_buffer` object moving the content of the other object to it.
`~basic_memory_buffer` [destructor]	Destructor
`operator=`	Moves the content of the other `basic_memory_buffer` object to this one.
`append`
`get_allocator`
`reserve`	Increases the buffer capacity to `new_capacity`.
`resize`	Resizes the buffer to contain `count` elements. If T is a POD type new elements may not be initialized.

Synopsis

Declared in <fmt/format.h>

using const_reference = T const&;

Synopsis

Declared in <fmt/format.h>

using value_type = T;

Synopses

Declared in <fmt/format.h>

Constructs a basic_memory_buffer object moving the content of the other object to it.

constexpr
basic_memory_buffer(basic_memory_buffer&& other) noexcept;

» more...

Default constructor

constexpr
explicit
basic_memory_buffer(Allocator const& alloc = Allocator());

» more...

Synopsis

Declared in <fmt/format.h>

constexpr
basic_memory_buffer(basic_memory_buffer&& other) noexcept;

Parameters

Name	Description
other	The object to move construct from

Synopsis

Declared in <fmt/format.h>

constexpr
explicit
basic_memory_buffer(Allocator const& alloc = Allocator());

Parameters

Name	Description
alloc	The object to copy construct from

Synopsis

Declared in <fmt/format.h>

constexpr
~basic_memory_buffer();

Synopsis

Declared in <fmt/format.h>

basic_memory_buffer&
operator=(basic_memory_buffer&& other) noexcept;

Return Value

Reference to the current object

Parameters

Name	Description
other	The object to move assign from

Synopsis

Declared in <fmt/format.h>

template<typename ContiguousRange>
constexpr
void
append(ContiguousRange const& range);

Synopsis

Declared in <fmt/format.h>

Allocator
get_allocator() const;

Synopsis

Declared in <fmt/format.h>

void
reserve(size_t new_capacity);

Synopsis

Declared in <fmt/format.h>

constexpr
void
resize(size_t count);

Synopsis

Declared in <fmt/ostream.h>

template<typename Char>
struct basic_ostream_formatter
    : formatter<basic_string_view<Char>, Char>

Base Classes

Name	Description
`formatter<basic_string_view<Char>, Char>`

Member Functions

Name
`format`
`set_debug_format` [deleted]

Derived Classes

Name	Description
`formatter<std::thread::id, Char>`
`formatter</* implementation-defined */, Char>`

Synopsis

Declared in <fmt/ostream.h>

template<
    typename T,
    typename Context>
decltype(ctx.out())
format(
    T const& value,
    Context& ctx) const;

Synopsis

Declared in <fmt/ostream.h>

void
set_debug_format() = delete;

Synopsis

Declared in <fmt/printf.h>

template<typename Char>
class basic_printf_context;

Type Aliases

Name
`char_type`

Enums

Name
`Unnamed enum`

Member Functions

Name	Description
`basic_printf_context` [constructor]	Constructs a `printf_context` object. References to the arguments are stored in the context object so make sure they have appropriate lifetimes.
`advance_to`
`arg`
`locale`
`out`

Synopsis

Declared in <fmt/printf.h>

using char_type = Char;

Synopsis

Declared in <fmt/printf.h>

enum Unnamed enum;

Members

Name
`builtin_types`

Synopsis

Declared in <fmt/printf.h>

basic_printf_context(
    basic_appender<Char> out,
    basic_format_args<basic_printf_context> args);

Parameters

Name	Description
out	The object to construct from
args	A view of a collection of formatting arguments. To avoid lifetime issues it should only be used as a parameter type in type-erased functions such as `vformat`:

Synopsis

Declared in <fmt/printf.h>

void
advance_to(basic_appender<Char>);

Synopsis

Declared in <fmt/printf.h>

basic_format_arg<basic_printf_context>
arg(int id) const;

Synopsis

Declared in <fmt/printf.h>

locale_ref
locale();

Synopsis

Declared in <fmt/printf.h>

basic_appender<Char>
out();

Synopsis

Declared in <fmt/base.h>

class basic_specs;

Member Functions

Name
`align`
`alt`
`clear_alt`
`copy_fill_from`
`dynamic`
`dynamic_precision`
`dynamic_width`
`fill`
`fill_size`
`fill_unit`
`localized`
`set_align`
`set_alt`
`set_dynamic_precision`
`set_dynamic_width`
`set_fill`
`set_localized`
`set_sign`
`set_type`
`set_upper`
`sign`
`type`
`upper`

Derived Classes

Name	Description
`format_specs`

Synopsis

Declared in <fmt/base.h>

constexpr
align
align() const;

Synopsis

Declared in <fmt/base.h>

constexpr
bool
alt() const;

Synopsis

Declared in <fmt/base.h>

constexpr
void
clear_alt();

Synopsis

Declared in <fmt/base.h>

constexpr
void
copy_fill_from(basic_specs const& specs);

Synopsis

Declared in <fmt/base.h>

constexpr
bool
dynamic() const;

Synopsis

Declared in <fmt/base.h>

constexpr
arg_id_kind
dynamic_precision() const;

Synopsis

Declared in <fmt/base.h>

constexpr
arg_id_kind
dynamic_width() const;

Synopses

Declared in <fmt/base.h>

template<typename Char>
constexpr
Char const*
fill() const;

» more...

template<typename Char>
constexpr
Char const*
fill() const;

» more...

Synopsis

Declared in <fmt/base.h>

template<typename Char>
constexpr
Char const*
fill() const;

Synopsis

Declared in <fmt/base.h>

template<typename Char>
constexpr
Char const*
fill() const;

Synopsis

Declared in <fmt/base.h>

constexpr
size_t
fill_size() const;

Synopsis

Declared in <fmt/base.h>

template<typename Char>
constexpr
Char
fill_unit() const;

Synopsis

Declared in <fmt/base.h>

constexpr
bool
localized() const;

Synopsis

Declared in <fmt/base.h>

constexpr
void
set_align(fmt::align a);

Synopsis

Declared in <fmt/base.h>

constexpr
void
set_alt();

Synopsis

Declared in <fmt/base.h>

constexpr
void
set_dynamic_precision(arg_id_kind p);

Synopsis

Declared in <fmt/base.h>

constexpr
void
set_dynamic_width(arg_id_kind w);

Synopses

Declared in <fmt/base.h>

constexpr
void
set_fill(char c);

» more...

template<typename Char>
constexpr
void
set_fill(basic_string_view<Char> s);

» more...

Synopsis

Declared in <fmt/base.h>

constexpr
void
set_fill(char c);

Synopsis

Declared in <fmt/base.h>

template<typename Char>
constexpr
void
set_fill(basic_string_view<Char> s);

Synopsis

Declared in <fmt/base.h>

constexpr
void
set_localized();

Synopsis

Declared in <fmt/base.h>

constexpr
void
set_sign(fmt::sign s);

Synopsis

Declared in <fmt/base.h>

constexpr
void
set_type(presentation_type t);

Synopsis

Declared in <fmt/base.h>

constexpr
void
set_upper();

Synopsis

Declared in <fmt/base.h>

constexpr
sign
sign() const;

Synopsis

Declared in <fmt/base.h>

constexpr
presentation_type
type() const;

Synopsis

Declared in <fmt/base.h>

constexpr
bool
upper() const;

Synopsis

Declared in <fmt/base.h>

template<typename Char>
class basic_string_view;

Type Aliases

Name
`iterator`
`value_type`

Member Functions

Name	Description
`basic_string_view` [constructor]	Constructors
`begin`
`compare`
`data`
`end`
`operator[]`
`remove_prefix`
`size`
`starts_with`

Friends

Name	Description
`fmt::operator>=`	Greater-than-or-equal operator
`fmt::operator>`	Greater-than operator
`fmt::operator<=`	Less-than-or-equal operator
`fmt::operator<`	Less-than operator
`fmt::operator!=`	Inequality operator
`fmt::operator==`	Equality operator

Synopsis

Declared in <fmt/base.h>

using iterator = Char const*;

Synopsis

Declared in <fmt/base.h>

using value_type = Char;

Synopses

Declared in <fmt/base.h>

Default constructor

constexpr
basic_string_view() noexcept;

» more...

Construct from Char

constexpr
basic_string_view(Char const* s);

» more...

Construct from S

template<typename S>
constexpr
basic_string_view(S const& s) noexcept;

» more...

constexpr
basic_string_view(
    Char const* s,
    size_t count) noexcept;

» more...

Synopsis

Declared in <fmt/base.h>

constexpr
basic_string_view() noexcept;

Synopsis

Declared in <fmt/base.h>

constexpr
basic_string_view(Char const* s);

Parameters

Name	Description
s	The object to construct from

Synopsis

Declared in <fmt/base.h>

template<typename S>
constexpr
basic_string_view(S const& s) noexcept;

Parameters

Name	Description
s	The object to copy construct from

Synopsis

Declared in <fmt/base.h>

constexpr
basic_string_view(
    Char const* s,
    size_t count) noexcept;

Synopsis

Declared in <fmt/base.h>

constexpr
iterator
begin() const noexcept;

Synopsis

Declared in <fmt/base.h>

constexpr
int
compare(basic_string_view other) const;

Synopsis

Declared in <fmt/base.h>

constexpr
Char const*
data() const noexcept;

Synopsis

Declared in <fmt/base.h>

constexpr
iterator
end() const noexcept;

Synopsis

Declared in <fmt/base.h>

constexpr
Char const&
operator[](size_t pos) const noexcept;

Synopsis

Declared in <fmt/base.h>

constexpr
void
remove_prefix(size_t n) noexcept;

Synopsis

Declared in <fmt/base.h>

constexpr
size_t
size() const noexcept;

Synopses

Declared in <fmt/base.h>

constexpr
bool
starts_with(Char c) const noexcept;

» more...

constexpr
bool
starts_with(basic_string_view sv) const noexcept;

» more...

constexpr
bool
starts_with(Char const* s) const;

» more...

Synopsis

Declared in <fmt/base.h>

constexpr
bool
starts_with(Char c) const noexcept;

Synopsis

Declared in <fmt/base.h>

constexpr
bool
starts_with(basic_string_view sv) const noexcept;

Synopsis

Declared in <fmt/base.h>

constexpr
bool
starts_with(Char const* s) const;

Synopsis

Declared in <fmt/os.h>

class buffered_file;

Member Functions

Name	Description
`buffered_file` [constructor]	Constructors
`~buffered_file` [destructor]	Destructor
`operator=` [deleted]	Assignment operators
`close`
`descriptor`
`get`
`print`

Friends

Name	Description
`fmt::file`

Synopses

Declared in <fmt/os.h>

Default constructor

buffered_file() noexcept;

» more...

Copy constructor

buffered_file(buffered_file const& other) = delete;

» more...

Move constructor

buffered_file(buffered_file&& other) noexcept;

» more...

buffered_file(
    cstring_view filename,
    cstring_view mode);

» more...

Synopsis

Declared in <fmt/os.h>

buffered_file() noexcept;

Synopsis

Declared in <fmt/os.h>

buffered_file(buffered_file const& other) = delete;

Parameters

Name	Description
other	The object to copy construct from

Synopsis

Declared in <fmt/os.h>

buffered_file(buffered_file&& other) noexcept;

Parameters

Name	Description
other	The object to move construct from

Synopsis

Declared in <fmt/os.h>

buffered_file(
    cstring_view filename,
    cstring_view mode);

Synopsis

Declared in <fmt/os.h>

~buffered_file() noexcept;

Synopses

Declared in <fmt/os.h>

void
operator=(buffered_file const& other) = delete;

» more...

Move assignment operator

buffered_file&
operator=(buffered_file&& other);

» more...

Synopsis

Declared in <fmt/os.h>

void
operator=(buffered_file const& other) = delete;

Synopsis

Declared in <fmt/os.h>

buffered_file&
operator=(buffered_file&& other);

Return Value

Reference to the current object

Parameters

Name	Description
other	The object to move assign from

Synopsis

Declared in <fmt/os.h>

void
close();

Synopsis

Declared in <fmt/os.h>

int
descriptor() const;

Synopsis

Declared in <fmt/os.h>

FILE*
get() const noexcept;

Synopsis

Declared in <fmt/os.h>

template<typename... T>
void
print(
    string_view fmt,
    T const&... args);

Synopsis

Declared in <fmt/format.h>

struct bytes;

Member Functions

Name	Description
`bytes` [constructor]	Construct from `string_view`

Data Members

Name
`data`

Synopsis

Declared in <fmt/format.h>

explicit
bytes(string_view s);

Parameters

Name	Description
s	The object to construct from

Synopsis

Declared in <fmt/format.h>

string_view data;

Synopsis

Declared in <fmt/compile.h>

class compiled_string;

Synopsis

Declared in <fmt/ranges.h>

template<typename...>
struct conjunction
    : std::true_type

Base Classes

Name	Description
`std::true_type`

Synopsis

Declared in <fmt/ranges.h>

template<typename P>
struct conjunction<P>
    : P

Base Classes

Name	Description
`P`

Synopsis

Declared in <fmt/ranges.h>

template<
    typename P1,
    typename... Pn>
struct conjunction<P1, Pn...>
    : conditional_t<bool(P1::value), conjunction<Pn...>, P1>

Base Classes

Name	Description
`conditional_t<bool(P1::value), conjunction<Pn...>, P1>`

Synopsis

Declared in <fmt/base.h>

class context;

Type Aliases

Name
`char_type`
`format_arg`
`iterator`

Enums

Name
`Unnamed enum`

Member Functions

Name	Description
`context` [constructor] [deleted]	Constructs a `context` object. References to the arguments are stored in the object so make sure they have appropriate lifetimes.
`operator=` [deleted]
`advance_to`
`arg`
`arg_id`
`args`
`locale`
`out`

Synopsis

Declared in <fmt/base.h>

using char_type = char;

Synopsis

Declared in <fmt/base.h>

using format_arg = basic_format_arg<context>;

Synopsis

Declared in <fmt/base.h>

using iterator = appender;

Synopsis

Declared in <fmt/base.h>

enum Unnamed enum;

Members

Name
`builtin_types`

Synopses

Declared in <fmt/base.h>

Copy constructor

context(context const& other) = delete;

» more...

Move constructor

constexpr
context(context&& other) = default;

» more...

Constructs a context object. References to the arguments are stored in the object so make sure they have appropriate lifetimes.

constexpr
context(
    iterator out,
    format_args args,
    locale_ref loc = {});

» more...

Synopsis

Declared in <fmt/base.h>

context(context const& other) = delete;

Parameters

Name	Description
other	The object to copy construct from

Synopsis

Declared in <fmt/base.h>

constexpr
context(context&& other) = default;

Parameters

Name	Description
other	The object to move construct from

Synopsis

Declared in <fmt/base.h>

constexpr
context(
    iterator out,
    format_args args,
    locale_ref loc = {});

Parameters

Name	Description
out	The object to construct from

Synopsis

Declared in <fmt/base.h>

void
operator=(context const& other) = delete;

Synopsis

Declared in <fmt/base.h>

constexpr
void
advance_to(iterator);

Synopses

Declared in <fmt/base.h>

constexpr
format_arg
arg(int id) const;

» more...

format_arg
arg(string_view name) const;

» more...

Synopsis

Declared in <fmt/base.h>

constexpr
format_arg
arg(int id) const;

Synopsis

Declared in <fmt/base.h>

format_arg
arg(string_view name) const;

Synopsis

Declared in <fmt/base.h>

constexpr
int
arg_id(string_view name) const;

Synopsis

Declared in <fmt/base.h>

format_args const&
args() const;

Synopsis

Declared in <fmt/base.h>

constexpr
locale_ref
locale() const;

Synopsis

Declared in <fmt/base.h>

constexpr
iterator
out() const;

Synopsis

Declared in <fmt/args.h>

template<typename Context>
class dynamic_format_arg_store;

Description

It can be implicitly converted into fmt::basic_format_args for passing into type-erased formatting functions such as fmt::vformat.

Member Functions

Name	Description
`dynamic_format_arg_store` [constructor]	Default constructor
`clear`	Erase all elements from the store.
`push_back`	`push_back` overloads
`reserve`	Reserves space to store at least `new_cap` arguments including `new_cap_named` named arguments.
`size`	Returns the number of elements in the store.
`operator basic_format_args<Context>`	Conversion to `basic_format_args`

Friends

Name	Description
`fmt::basic_format_args`	A view of a collection of formatting arguments. To avoid lifetime issues it should only be used as a parameter type in type-erased functions such as `vformat`:

Synopsis

Declared in <fmt/args.h>

constexpr
dynamic_format_arg_store() = default;

Synopsis

Declared in <fmt/args.h>

void
clear();

Synopses

Declared in <fmt/args.h>

Adds a reference to the argument into the dynamic store for later passing to a formatting function.

template<typename T>
void
push_back(std::reference_wrapper<T> arg);

» more...

Adds an argument into the dynamic store for later passing to a formatting function.

template<typename T>
void
push_back(T const& arg);

» more...

Adds named argument into the dynamic store for later passing to a formatting function. std::reference_wrapper is supported to avoid copying of the argument. The name is always copied into the store.

template<typename T>
void
push_back(named_arg<T, char_type> const& arg);

» more...

Synopsis

Declared in <fmt/args.h>

template<typename T>
void
push_back(std::reference_wrapper<T> arg);

Description

Example:

fmt::dynamic_format_arg_store<fmt::format_context> store; char band[]= "Rolling Stones"; store.push_back(std::cref(band)); band[9]= 'c'; // Changing str affects the output. std::string result = fmt::vformat("{}", store); // result == "Rolling Scones"

Parameters

Name	Description
arg	Primary class template for reference_wrapper.

Synopsis

Declared in <fmt/args.h>

template<typename T>
void
push_back(T const& arg);

Description

Note that custom types and string types (but not string views) are copied into the store dynamically allocating memory if necessary.

Example:

fmt::dynamic_format_arg_store<fmt::format_context> store; store.push_back(42); store.push_back("abc"); store.push_back(1.5f); std::string result = fmt::vformat("{} and {} and {}", store);

Synopsis

Declared in <fmt/args.h>

template<typename T>
void
push_back(named_arg<T, char_type> const& arg);

Synopsis

Declared in <fmt/args.h>

void
reserve(
    size_t new_cap,
    size_t new_cap_named);

Synopsis

Declared in <fmt/args.h>

size_t
size() const noexcept;

Return Value

the number of elements in the store.

Synopsis

Declared in <fmt/args.h>

operator basic_format_args<Context>() const;

Return Value

A view of a collection of formatting arguments. To avoid lifetime issues it should only be used as a parameter type in type-erased functions such as vformat:

Synopsis

Declared in <fmt/os.h>

class file;

Synopsis

Declared in <fmt/format.h>

class format_error
    : public std::runtime_error

Base Classes

Name	Description
`std::runtime_error`	One of two subclasses of exception.

Member Functions

Name	Description
`operator=`	Assignment operators
`what` [virtual]	Returns a C-style character string describing the general cause of the current error (the same string passed to the ctor).

Using Declarations

Name
`format_error`

Synopses

Declared in <stdexcept>

Assignment operator

runtime_error&
operator=(runtime_error const& value) noexcept;

» more...

Assignment operator

runtime_error&
operator=(runtime_error&& value) noexcept;

» more...

Synopsis

Declared in <stdexcept>

runtime_error&
operator=(runtime_error const& value) noexcept;

Return Value

One of two subclasses of exception.

Parameters

Name	Description
value	The object to copy assign from

Synopsis

Declared in <stdexcept>

runtime_error&
operator=(runtime_error&& value) noexcept;

Return Value

One of two subclasses of exception.

Parameters

Name	Description
value	The object to move assign from

Synopsis

Declared in <stdexcept>

virtual
char const*
what() const noexcept;

Synopsis

Declared in <fmt/format.h>

using std::runtime_error::format_error;

Synopsis

Declared in <fmt/format.h>

template<typename Locale>
class format_facet
    : public Locale::facet

Base Classes

Name	Description
`Locale::facet`

Member Functions

Name	Description
`format_facet` [constructor]	Construct from `Locale`
`format_facet` [constructor]
`put`

Static Data Members

Name
`id`

Protected Member Functions

Name
`do_put` [virtual]

Synopsis

Declared in <fmt/format.h>

explicit
format_facet(Locale& loc);

Parameters

Name	Description
loc	The object to copy construct from

Synopsis

Declared in <fmt/format.h>

explicit
format_facet(
    string_view sep = "",
    std::string grouping = "\3",
    std::string decimal_point = ".");

Synopsis

Declared in <fmt/format.h>

bool
put(
    appender out,
    loc_value val,
    format_specs const& specs) const;

Synopsis

Declared in <fmt/format.h>

static
Locale::id id;

Synopsis

Declared in <fmt/format.h>

virtual
bool
do_put(
    appender out,
    loc_value val,
    format_specs const& specs) const;

Synopsis

Declared in <fmt/format.h>

template<>
class format_facet<locale>
    : public locale::facet

Base Classes

Name	Description
`locale::facet`	Localization functionality base class.

Member Functions

Name	Description
`format_facet` [constructor]	Constructors
`put`

Static Data Members

Name
`id`

Protected Types

Name
`__shim`

Protected Member Functions

Name	Description
`operator=` [deleted]	Assignment operator
`do_put` [virtual]

Protected Static Member Functions

Name
`_S_clone_c_locale`
`_S_create_c_locale`
`_S_destroy_c_locale`
`_S_get_c_locale`
`_S_get_c_name`
`_S_lc_ctype_c_locale`

Synopses

Declared in <fmt/format.h>

Construct from locale

explicit
format_facet(locale& loc);

» more...

explicit
format_facet(
    string_view sep = "",
    std::string grouping = "\3",
    std::string decimal_point = ".");

» more...

Synopsis

Declared in <fmt/format.h>

explicit
format_facet(locale& loc);

Parameters

Name	Description
loc	The object to copy construct from

Synopsis

Declared in <fmt/format.h>

explicit
format_facet(
    string_view sep = "",
    std::string grouping = "\3",
    std::string decimal_point = ".");

Synopsis

Declared in <fmt/format.h>

bool
put(
    appender out,
    loc_value val,
    format_specs const& specs) const;

Synopsis

Declared in <fmt/format.h>

static
locale::id id;

Synopsis

Declared in <bits/locale_classes.h>

class __shim;

Synopsis

Declared in <bits/locale_classes.h>

facet&
operator=(facet const& value) = delete;

Return Value

Localization functionality base class.

Parameters

Name	Description
value	The object to copy assign from

Synopsis

Declared in <fmt/format.h>

virtual
bool
do_put(
    appender out,
    loc_value val,
    format_specs const& specs) const;

Synopsis

Declared in <bits/locale_classes.h>

static
__c_locale
_S_clone_c_locale(__c_locale& __cloc);

Synopsis

Declared in <bits/locale_classes.h>

static
void
_S_create_c_locale(
    __c_locale& __cloc,
    char const* __s,
    __c_locale __old = 0);

Synopsis

Declared in <bits/locale_classes.h>

static
void
_S_destroy_c_locale(__c_locale& __cloc);

Synopsis

Declared in <bits/locale_classes.h>

static
__c_locale
_S_get_c_locale();

Synopsis

Declared in <bits/locale_classes.h>

[[__const__]]
static
char const*
_S_get_c_name();

Synopsis

Declared in <bits/locale_classes.h>

static
__c_locale
_S_lc_ctype_c_locale(
    __c_locale __cloc,
    char const* __s);

Synopsis

Declared in <fmt/format.h>

class format_int;

Member Functions

Name	Description
`format_int` [constructor]	Constructors
`c_str`	Returns a pointer to the output buffer content with terminating null character appended.
`data`	Returns a pointer to the output buffer content. No terminating null character is appended.
`size`	Returns the number of characters written to the output buffer.
`str`	Returns the content of the output buffer as an `std::string`.

Synopses

Declared in <fmt/format.h>

Construct from int

constexpr
explicit
format_int(int value);

» more...

Construct from long

constexpr
explicit
format_int(long value);

» more...

Construct from long long

constexpr
explicit
format_int(long long value);

» more...

Construct from ullong

constexpr
explicit
format_int(ullong value);

» more...

Construct from unsigned int

constexpr
explicit
format_int(unsigned int value);

» more...

Construct from unsigned long

constexpr
explicit
format_int(unsigned long value);

» more...

Synopsis

Declared in <fmt/format.h>

constexpr
explicit
format_int(int value);

Parameters

Name	Description
value	The value to construct from

Synopsis

Declared in <fmt/format.h>

constexpr
explicit
format_int(long value);

Parameters

Name	Description
value	The value to construct from

Synopsis

Declared in <fmt/format.h>

constexpr
explicit
format_int(long long value);

Parameters

Name	Description
value	The value to construct from

Synopsis

Declared in <fmt/format.h>

constexpr
explicit
format_int(ullong value);

Parameters

Name	Description
value	The object to construct from

Synopsis

Declared in <fmt/format.h>

constexpr
explicit
format_int(unsigned int value);

Parameters

Name	Description
value	The value to construct from

Synopsis

Declared in <fmt/format.h>

constexpr
explicit
format_int(unsigned long value);

Parameters

Name	Description
value	The value to construct from

Synopsis

Declared in <fmt/format.h>

constexpr
char const*
c_str() const;

Synopsis

Declared in <fmt/format.h>

constexpr
char const*
data() const;

Synopsis

Declared in <fmt/format.h>

constexpr
size_t
size() const;

Return Value

the number of characters written to the output buffer.

Synopsis

Declared in <fmt/format.h>

std::string
str() const;

Return Value

the content of the output buffer as an std::string.

Synopsis

Declared in <fmt/base.h>

struct format_specs
    : basic_specs

Base Classes

Name	Description
`basic_specs`

Member Functions

Name	Description
`format_specs` [constructor]	Default constructor
`align`
`alt`
`clear_alt`
`copy_fill_from`
`dynamic`
`dynamic_precision`
`dynamic_width`
`fill`
`fill_size`
`fill_unit`
`localized`
`set_align`
`set_alt`
`set_dynamic_precision`
`set_dynamic_width`
`set_fill`
`set_localized`
`set_sign`
`set_type`
`set_upper`
`sign`
`type`
`upper`

Data Members

Name
`precision`
`width`

Synopsis

Declared in <fmt/base.h>

constexpr
format_specs();

Synopsis

Declared in <fmt/base.h>

int precision;

Synopsis

Declared in <fmt/base.h>

int width;

Synopsis

Declared in <fmt/base.h>

template<typename OutputIt>
struct format_to_n_result;

Data Members

Name	Description
`out`	Iterator past the end of the output range.
`size`	Total (not truncated) output size.

Non-Member Functions

Name	Description
`format_to_n`	Formats `args` according to specifications in `fmt`, writes up to `n` characters of the result to the output iterator `out` and returns the total (not truncated) output size and the iterator past the end of the output range. `format_to_n` does not append a terminating null character.

Synopsis

Declared in <fmt/base.h>

OutputIt out;

Synopsis

Declared in <fmt/base.h>

size_t size;

Synopsis

Declared in <fmt/base.h>

struct format_to_result;

Member Functions

Name	Description
`operator char*`	Conversion to `char`

Data Members

Name	Description
`out`	Pointer to just after the last successful write.
`truncated`	Specifies if the output was truncated.

Synopsis

Declared in <fmt/base.h>

constexpr
operator char*() const;

Return Value

The object converted to char

Synopsis

Declared in <fmt/base.h>

char* out;

Synopsis

Declared in <fmt/base.h>

bool truncated;

Synopsis

Declared in <fmt/base.h>

template<
    typename T,
    typename Char = char,
    typename Enable = void>
struct formatter;

Member Functions

Name	Description
`formatter` [constructor] [deleted]	Default constructor

Derived Classes

Name	Description
`basic_ostream_formatter`
`formatter<Char*, Char>`
`formatter<signed char, Char>`
`formatter<std::atomic_flag, Char>`
`formatter</* implementation-defined */, Char>`
`formatter<std::reference_wrapper<T>, Char>`
`formatter<utc_time<Duration>, Char>`
`formatter<T, Char>`
`formatter<unsigned long, Char>`
`formatter<T, Char, void_t</* implementation-defined */>>`
`formatter</* implementation-defined */, Char>`
`formatter</* implementation-defined */, Char>`
`formatter<std::nullptr_t, Char>`
`formatter<long, Char>`
`formatter<short, Char>`
`formatter<unsigned char, Char>`
`formatter<BitRef, Char>`
`formatter<void*, Char>`
`formatter<std::basic_string<Char, Traits, Allocator>, Char>`
`formatter<std::atomic<T>, Char>`
`formatter<Char[N], Char>`
`formatter<std::byte, Char>`
`formatter<unsigned short, Char>`
`formatter<group_digits_view<T>>`

Synopsis

Declared in <fmt/base.h>

formatter() = delete;

Synopsis

Declared in <fmt/format-inl.h>

template<>
struct formatter</* implementation-defined */>;

Member Functions

Name
`format`
`parse`

Synopsis

Declared in <fmt/format-inl.h>

format_context::iterator
format(
    /* implementation-defined */ const& n,
    format_context& ctx) const;

Synopsis

Declared in <fmt/format-inl.h>

constexpr
format_parse_context::iterator
parse(format_parse_context& ctx);

Synopsis

Declared in <fmt/format.h>

template<>
struct formatter<bytes>;

Member Functions

Name
`format`
`parse`

Synopsis

Declared in <fmt/format.h>

template<typename FormatContext>
decltype(ctx.out())
format(
    bytes b,
    FormatContext& ctx) const;

Synopsis

Declared in <fmt/format.h>

constexpr
char const*
parse(parse_context<>& ctx);

Synopsis

Declared in <fmt/std.h>

template<>
struct formatter<std::error_code>;

Member Functions

Name
`format`
`parse`
`set_debug_format`

Synopsis

Declared in <fmt/std.h>

template<typename FormatContext>
constexpr
decltype(ctx.out())
format(
    std::error_code const& ec,
    FormatContext& ctx) const;

Synopsis

Declared in <fmt/std.h>

constexpr
char const*
parse(parse_context<>& ctx);

Synopsis

Declared in <fmt/std.h>

constexpr
void
set_debug_format(bool set = true);

Synopsis

Declared in <fmt/std.h>

template<>
struct formatter<std::source_location>;

Member Functions

Name
`format`
`parse`

Synopsis

Declared in <fmt/std.h>

template<typename FormatContext>
decltype(ctx.out())
format(
    std::source_location const& loc,
    FormatContext& ctx) const;

Synopsis

Declared in <fmt/std.h>

constexpr
auto
parse(parse_context<>& ctx);

Synopsis

Declared in <fmt/std.h>

template<>
struct formatter<std::type_info>;

Member Functions

Name
`format`
`parse`

Synopsis

Declared in <fmt/std.h>

template<typename Context>
decltype(ctx.out())
format(
    std::type_info const& ti,
    Context& ctx) const;

Synopsis

Declared in <fmt/std.h>

constexpr
char const*
parse(parse_context<>& ctx);

Synopsis

Declared in <fmt/format.h>

template<typename T>
struct formatter<group_digits_view<T>>
    : formatter<T>

Base Classes

Name	Description
`formatter<T>`

Member Functions

Name
`format`
`parse`

Synopsis

Declared in <fmt/format.h>

template<typename FormatContext>
decltype(ctx.out())
format(
    group_digits_view<T> view,
    FormatContext& ctx) const;

Synopsis

Declared in <fmt/format.h>

constexpr
char const*
parse(parse_context<>& ctx);

Synopsis

Declared in <fmt/std.h>

template<typename T>
requires std::is_base_of<std::exception, T>::value
struct formatter<T, char>;

Member Functions

Name
`format`
`parse`

Synopsis

Declared in <fmt/std.h>

template<typename Context>
decltype(ctx.out())
format(
    std::exception const& ex,
    Context& ctx) const;

Synopsis

Declared in <fmt/std.h>

constexpr
char const*
parse(parse_context<>& ctx);

Synopsis

Declared in <fmt/std.h>

template<typename Char>
struct formatter<std::atomic_flag, Char>
    : formatter<bool, Char>

Base Classes

Name	Description
`formatter<bool, Char>`

Member Functions

Name
`format`

Synopsis

Declared in <fmt/std.h>

template<typename FormatContext>
decltype(ctx.out())
format(
    std::atomic_flag const& v,
    FormatContext& ctx) const;

Synopsis

Declared in <fmt/std.h>

template<typename Char>
struct formatter<std::byte, Char>
    : formatter<unsigned int, Char>

Base Classes

Name	Description
`formatter<unsigned int, Char>`

Member Functions

Name
`format`

Static Member Functions

Name
`format_as`

Synopsis

Declared in <fmt/std.h>

template<typename Context>
constexpr
decltype(ctx.out())
format(
    std::byte b,
    Context& ctx) const;

Synopsis

Declared in <fmt/std.h>

constexpr
static
unsigned char
format_as(std::byte b);

Synopsis

Declared in <fmt/chrono.h>

template<typename Char>
struct formatter<day, Char>;

Member Functions

Name
`format`
`parse`

Synopsis

Declared in <fmt/chrono.h>

template<typename FormatContext>
decltype(ctx.out())
format(
    day d,
    FormatContext& ctx) const;

Synopsis

Declared in <fmt/chrono.h>

constexpr
Char const*
parse(parse_context<Char>& ctx);

Synopsis

Declared in <fmt/format.h>

template<typename Char>
struct formatter</* implementation-defined */, Char>
    : /* implementation-defined */

Base Classes

Name	Description
`/* implementation-defined */`

Member Functions

Name
`format`
`parse`
`set_debug_format`

Synopsis

Declared in <fmt/base.h>

template<typename FormatContext>
constexpr
decltype(ctx.out())
format(
    T const& val,
    FormatContext& ctx) const;

Synopsis

Declared in <fmt/base.h>

constexpr
Char const*
parse(parse_context<Char>& ctx);

Synopsis

Declared in <fmt/base.h>

template</* implementation-defined */ U = TYPE>
constexpr
void
set_debug_format(bool set = true);

Synopsis

Declared in <fmt/std.h>

template<typename Char>
struct formatter<std::thread::id, Char>
    : basic_ostream_formatter<Char>

Base Classes

Name	Description
`basic_ostream_formatter<Char>`

Member Functions

Name
`format`
`set_debug_format` [deleted]

Synopsis

Declared in <fmt/format.h>

template<typename Char>
struct formatter<long, Char>
    : formatter</* implementation-defined */, Char>

Base Classes

Name	Description
`formatter</* implementation-defined */, Char>`

Member Functions

Name
`format`

Synopsis

Declared in <fmt/format.h>

template<typename FormatContext>
constexpr
decltype()
format(
    long value,
    FormatContext& ctx) const;

Synopsis

Declared in <fmt/std.h>

template<typename Char>
struct formatter<std::monostate, Char>;

Member Functions

Name
`format`
`parse`

Synopsis

Declared in <fmt/std.h>

template<typename FormatContext>
constexpr
decltype(ctx.out())
format(
    std::monostate const&,
    FormatContext& ctx) const;

Synopsis

Declared in <fmt/std.h>

constexpr
Char const*
parse(parse_context<Char>& ctx);

Synopsis

Declared in <fmt/chrono.h>

template<typename Char>
struct formatter<month, Char>;

Member Functions

Name
`format`
`parse`

Synopsis

Declared in <fmt/chrono.h>

template<typename FormatContext>
decltype(ctx.out())
format(
    month m,
    FormatContext& ctx) const;

Synopsis

Declared in <fmt/chrono.h>

constexpr
Char const*
parse(parse_context<Char>& ctx);

Synopsis

Declared in <fmt/format.h>

template<typename Char>
struct formatter<std::nullptr_t, Char>
    : formatter<void const*, Char>

Base Classes

Name	Description
`formatter<void const*, Char>`

Member Functions

Name
`format`

Synopsis

Declared in <fmt/format.h>

template<typename FormatContext>
constexpr
decltype()
format(
    std::nullptr_t value,
    FormatContext& ctx) const;

Synopsis

Declared in <fmt/std.h>

template<typename Char>
struct formatter<std::filesystem::path, Char>;

Member Functions

Name
`format`
`parse`
`set_debug_format`

Synopsis

Declared in <fmt/std.h>

template<typename FormatContext>
auto
format(
    std::filesystem::path const& p,
    FormatContext& ctx) const;

Synopsis

Declared in <fmt/std.h>

constexpr
auto
parse(parse_context<Char>& ctx);

Synopsis

Declared in <fmt/std.h>

constexpr
void
set_debug_format(bool set = true);

Synopsis

Declared in <fmt/format.h>

template<typename Char>
struct formatter<short, Char>
    : formatter<int, Char>

Base Classes

Name	Description
`formatter<int, Char>`

Member Functions

Name
`format`

Synopsis

Declared in <fmt/format.h>

template<typename FormatContext>
constexpr
decltype()
format(
    short value,
    FormatContext& ctx) const;

Synopsis

Declared in <fmt/format.h>

template<typename Char>
struct formatter<signed char, Char>
    : formatter<int, Char>

Base Classes

Name	Description
`formatter<int, Char>`

Member Functions

Name
`format`

Synopsis

Declared in <fmt/format.h>

template<typename FormatContext>
constexpr
decltype()
format(
    signed char value,
    FormatContext& ctx) const;

Synopsis

Declared in <fmt/chrono.h>

template<typename Char>
struct formatter<tm, Char>;

Member Functions

Name
`format`
`parse`

Protected Member Functions

Name
`do_format`
`do_parse`
`localized`
`set_localized`

Synopsis

Declared in <fmt/chrono.h>

template<typename FormatContext>
decltype(ctx.out())
format(
    tm const& tm,
    FormatContext& ctx) const;

Synopsis

Declared in <fmt/chrono.h>

constexpr
Char const*
parse(parse_context<Char>& ctx);

Synopsis

Declared in <fmt/chrono.h>

template<
    typename Duration,
    typename FormatContext>
decltype(ctx.out())
do_format(
    tm const& tm,
    FormatContext& ctx,
    Duration const* subsecs) const;

Synopsis

Declared in <fmt/chrono.h>

constexpr
Char const*
do_parse(
    parse_context<Char>& ctx,
    bool has_timezone);

Synopsis

Declared in <fmt/chrono.h>

bool
localized() const;

Synopsis

Declared in <fmt/chrono.h>

constexpr
void
set_localized();

Synopsis

Declared in <fmt/format.h>

template<typename Char>
struct formatter<unsigned char, Char>
    : formatter<unsigned int, Char>

Base Classes

Name	Description
`formatter<unsigned int, Char>`

Member Functions

Name
`format`

Synopsis

Declared in <fmt/format.h>

template<typename FormatContext>
constexpr
decltype()
format(
    unsigned char value,
    FormatContext& ctx) const;

Synopsis

Declared in <fmt/format.h>

template<typename Char>
struct formatter<unsigned long, Char>
    : formatter</* implementation-defined */, Char>

Base Classes

Name	Description
`formatter</* implementation-defined */, Char>`

Member Functions

Name
`format`

Synopsis

Declared in <fmt/format.h>

template<typename FormatContext>
constexpr
decltype()
format(
    unsigned long value,
    FormatContext& ctx) const;

Synopsis

Declared in <fmt/format.h>

template<typename Char>
struct formatter<unsigned short, Char>
    : formatter<unsigned int, Char>

Base Classes

Name	Description
`formatter<unsigned int, Char>`

Member Functions

Name
`format`

Synopsis

Declared in <fmt/format.h>

template<typename FormatContext>
constexpr
decltype()
format(
    unsigned short value,
    FormatContext& ctx) const;

Synopsis

Declared in <fmt/chrono.h>

template<typename Char>
struct formatter<weekday, Char>;

Member Functions

Name
`format`
`parse`

Synopsis

Declared in <fmt/chrono.h>

template<typename FormatContext>
decltype(ctx.out())
format(
    weekday wd,
    FormatContext& ctx) const;

Synopsis

Declared in <fmt/chrono.h>

constexpr
Char const*
parse(parse_context<Char>& ctx);

Synopsis

Declared in <fmt/chrono.h>

template<typename Char>
struct formatter<year, Char>;

Member Functions

Name
`format`
`parse`

Synopsis

Declared in <fmt/chrono.h>

template<typename FormatContext>
decltype(ctx.out())
format(
    year y,
    FormatContext& ctx) const;

Synopsis

Declared in <fmt/chrono.h>

constexpr
Char const*
parse(parse_context<Char>& ctx);

Synopsis

Declared in <fmt/chrono.h>

template<typename Char>
struct formatter<year_month_day, Char>;

Member Functions

Name
`format`
`parse`

Synopsis

Declared in <fmt/chrono.h>

template<typename FormatContext>
decltype(ctx.out())
format(
    year_month_day val,
    FormatContext& ctx) const;

Synopsis

Declared in <fmt/chrono.h>

constexpr
Char const*
parse(parse_context<Char>& ctx);

Synopsis

Declared in <fmt/format.h>

template<typename Char>
struct formatter</* implementation-defined */, Char>
    : formatter<basic_string_view<Char>, Char>

Base Classes

Name	Description
`formatter<basic_string_view<Char>, Char>`

Member Functions

Name
`format`

Synopsis

Declared in <fmt/format.h>

template<typename FormatContext>
constexpr
decltype()
format(
    /* implementation-defined */ value,
    FormatContext& ctx) const;

Synopsis

Declared in <fmt/format.h>

template<typename Char>
struct formatter<Char*, Char>
    : formatter<Char const*, Char>

Base Classes

Name	Description
`formatter<Char const*, Char>`

Member Functions

Name
`format`

Synopsis

Declared in <fmt/format.h>

template<typename FormatContext>
constexpr
decltype()
format(
    Char* value,
    FormatContext& ctx) const;

Synopsis

Declared in <fmt/format.h>

template<typename Char>
struct formatter<void*, Char>
    : formatter<void const*, Char>

Base Classes

Name	Description
`formatter<void const*, Char>`

Member Functions

Name
`format`

Synopsis

Declared in <fmt/format.h>

template<typename FormatContext>
constexpr
decltype()
format(
    void* value,
    FormatContext& ctx) const;

Synopsis

Declared in <fmt/std.h>

template<
    typename BitRef,
    typename Char>
requires detail::is_bit_reference_like<BitRef>::value
struct formatter<BitRef, Char>
    : formatter<bool, Char>

Base Classes

Name	Description
`formatter<bool, Char>`

Member Functions

Name
`format`

Synopsis

Declared in <fmt/std.h>

template<typename FormatContext>
constexpr
decltype(ctx.out())
format(
    BitRef const& v,
    FormatContext& ctx) const;

Synopsis

Declared in <fmt/ranges.h>

template<
    typename R,
    typename Char>
requires conjunction<
        bool_constant<
            range_format_kind<R, Char>::value != range_format::disabled &&
            range_format_kind<R, Char>::value != range_format::map &&
            range_format_kind<R, Char>::value != range_format::string &&
            range_format_kind<R, Char>::value != range_format::debug_string>,
        detail::is_formattable_delayed<R, Char>>::value
struct formatter<R, Char>;

Type Aliases

Name
`nonlocking`

Member Functions

Name	Description
`formatter` [constructor]	Default constructor
`format`
`parse`

Synopsis

Declared in <fmt/ranges.h>

using nonlocking = void;

Synopsis

Declared in <fmt/ranges.h>

constexpr
formatter();

Synopsis

Declared in <fmt/ranges.h>

template<typename FormatContext>
constexpr
decltype(ctx.out())
format(
    range_type& range,
    FormatContext& ctx) const;

Synopsis

Declared in <fmt/ranges.h>

constexpr
Char const*
parse(parse_context<Char>& ctx);

Synopsis

Declared in <fmt/ranges.h>

template<
    typename R,
    typename Char>
requires conjunction<
        bool_constant<range_format_kind<R, Char>::value == range_format::map>,
        detail::is_formattable_delayed<R, Char>>::value
struct formatter<R, Char>;

Member Functions

Name	Description
`formatter` [constructor]	Default constructor
`format`
`parse`

Synopsis

Declared in <fmt/ranges.h>

constexpr
formatter();

Synopsis

Declared in <fmt/ranges.h>

template<typename FormatContext>
decltype(ctx.out())
format(
    map_type& map,
    FormatContext& ctx) const;

Synopsis

Declared in <fmt/ranges.h>

constexpr
Char const*
parse(parse_context<Char>& ctx);

Synopsis

Declared in <fmt/ranges.h>

template<
    typename R,
    typename Char>
requires range_format_kind<R, Char>::value == range_format::string ||
                range_format_kind<R, Char>::value ==
                    range_format::debug_string
struct formatter<R, Char>;

Member Functions

Name
`format`
`parse`

Synopsis

Declared in <fmt/ranges.h>

template<typename FormatContext>
decltype(ctx.out())
format(
    range_type& range,
    FormatContext& ctx) const;

Synopsis

Declared in <fmt/ranges.h>

constexpr
Char const*
parse(parse_context<Char>& ctx);

Synopsis

Declared in <fmt/base.h>

template<
    typename T,
    typename Char>
requires detail::type_constant<T, Char>::value !=
                             detail::type::custom_type
struct formatter<T, Char>
    : /* implementation-defined */

Base Classes

Name	Description
`/* implementation-defined */`

Member Functions

Name
`format`
`parse`
`set_debug_format`

Synopsis

Declared in <fmt/base.h>

template<typename FormatContext>
constexpr
decltype(ctx.out())
format(
    T const& val,
    FormatContext& ctx) const;

Synopsis

Declared in <fmt/base.h>

constexpr
Char const*
parse(parse_context<Char>& ctx);

Synopsis

Declared in <fmt/base.h>

template</* implementation-defined */ U = TYPE>
constexpr
void
set_debug_format(bool set = true);

Synopsis

Declared in <fmt/ranges.h>

template<
    typename T,
    typename Char>
requires conjunction<is_container_adaptor<T>,
                            bool_constant<range_format_kind<T, Char>::value ==
                                          range_format::disabled>>::value
struct formatter<T, Char>
    : formatter</* implementation-defined */, Char>

Base Classes

Name	Description
`formatter</* implementation-defined */, Char>`

Type Aliases

Name
`all`

Member Functions

Name
`format`

Synopsis

Declared in <fmt/ranges.h>

using all = /* implementation-defined */;

Synopsis

Declared in <fmt/ranges.h>

template<typename FormatContext>
decltype(ctx.out())
format(
    T const& value,
    FormatContext& ctx) const;

Synopsis

Declared in <fmt/ranges.h>

template<
    typename Tuple,
    typename Char>
requires fmt::is_tuple_like<Tuple>::value &&
                             fmt::is_tuple_formattable<Tuple, Char>::value
struct formatter<Tuple, Char>;

Member Functions

Name	Description
`formatter` [constructor]	Default constructor
`format`
`parse`
`set_brackets`
`set_separator`

Synopsis

Declared in <fmt/ranges.h>

constexpr
formatter();

Synopsis

Declared in <fmt/ranges.h>

template<typename FormatContext>
decltype(ctx.out())
format(
    Tuple const& value,
    FormatContext& ctx) const;

Synopsis

Declared in <fmt/ranges.h>

constexpr
Char const*
parse(parse_context<Char>& ctx);

Synopsis

Declared in <fmt/ranges.h>

constexpr
void
set_brackets(
    basic_string_view<Char> open,
    basic_string_view<Char> close);

Synopsis

Declared in <fmt/ranges.h>

constexpr
void
set_separator(basic_string_view<Char> sep);

Synopsis

Declared in <fmt/std.h>

template<
    typename Variant,
    typename Char>
requires std::conjunction_v<
                     is_variant_like<Variant>,
                     detail::is_variant_formattable<Variant, Char>>
struct formatter<Variant, Char>;

Member Functions

Name
`format`
`parse`

Synopsis

Declared in <fmt/std.h>

template<typename FormatContext>
constexpr
decltype(ctx.out())
format(
    Variant const& value,
    FormatContext& ctx) const;

Synopsis

Declared in <fmt/std.h>

constexpr
Char const*
parse(parse_context<Char>& ctx);

Synopsis

Declared in <fmt/std.h>

template<
    typename T,
    typename Char>
requires is_formattable<T, Char>::value
struct formatter<std::atomic<T>, Char>
    : formatter<T, Char>

Base Classes

Name	Description
`formatter<T, Char>`

Member Functions

Name
`format`

Synopsis

Declared in <fmt/std.h>

template<typename FormatContext>
decltype(ctx.out())
format(
    std::atomic<T> const& v,
    FormatContext& ctx) const;

Synopsis

Declared in <fmt/std.h>

template<
    size_t N,
    typename Char>
struct formatter<std::bitset<N>, Char>
    : nested_formatter<basic_string_view<Char>, Char>

Base Classes

Name	Description
`nested_formatter<basic_string_view<Char>, Char>`

Member Functions

Name
`format`
`nested`
`parse`
`write_padded`

Synopsis

Declared in <fmt/std.h>

template<typename FormatContext>
decltype(ctx.out())
format(
    std::bitset<N> const& bs,
    FormatContext& ctx) const;

Synopsis

Declared in <fmt/std.h>

template<
    typename T,
    typename Char>
struct formatter<std::complex<T>, Char>;

Member Functions

Name
`format`
`parse`

Synopsis

Declared in <fmt/std.h>

template<typename FormatContext>
decltype(ctx.out())
format(
    std::complex<T> const& c,
    FormatContext& ctx) const;

Synopsis

Declared in <fmt/std.h>

constexpr
Char const*
parse(parse_context<Char>& ctx);

Synopsis

Declared in <fmt/chrono.h>

template<
    typename Duration,
    typename Char>
struct formatter<local_time<Duration>, Char>;

Member Functions

Name
`format`
`parse`

Synopsis

Declared in <fmt/chrono.h>

template<typename FormatContext>
decltype(ctx.out())
format(
    local_time<Duration> val,
    FormatContext& ctx) const;

Synopsis

Declared in <fmt/chrono.h>

constexpr
Char const*
parse(parse_context<Char>& ctx);

Synopsis

Declared in <fmt/format.h>

template<
    typename T,
    typename Char>
struct formatter<nested_view<T, Char>, Char>;

Member Functions

Name
`format`
`parse`

Synopsis

Declared in <fmt/format.h>

template<typename FormatContext>
decltype(ctx.out())
format(
    nested_view<T, Char> view,
    FormatContext& ctx) const;

Synopsis

Declared in <fmt/format.h>

constexpr
Char const*
parse(parse_context<Char>& ctx);

Synopsis

Declared in <fmt/std.h>

template<
    typename T,
    typename Char>
requires is_formattable<T, Char>::value
struct formatter<std::optional<T>, Char>;

Member Functions

Name
`format`
`parse`

Synopsis

Declared in <fmt/std.h>

template<typename FormatContext>
decltype(ctx.out())
format(
    std::optional<T> const& opt,
    FormatContext& ctx) const;

Synopsis

Declared in <fmt/std.h>

constexpr
auto
parse(parse_context<Char>& ctx);

Synopsis

Declared in <fmt/std.h>

template<
    typename T,
    typename Char>
requires is_formattable<remove_cvref_t<T>, Char>::value &&
                             !detail::has_format_as<T>::value &&
                             !detail::has_format_as_member<T>::value
struct formatter<std::reference_wrapper<T>, Char>
    : formatter<remove_cvref_t<T>, Char>

Base Classes

Name	Description
`formatter<remove_cvref_t<T>, Char>`

Member Functions

Name
`format`

Synopsis

Declared in <fmt/std.h>

template<typename FormatContext>
decltype(ctx.out())
format(
    std::reference_wrapper<T> ref,
    FormatContext& ctx) const;

Synopsis

Declared in <fmt/ostream.h>

template<
    typename T,
    typename Char>
struct formatter</* implementation-defined */, Char>
    : basic_ostream_formatter<Char>

Base Classes

Name	Description
`basic_ostream_formatter<Char>`

Member Functions

Name
`format`
`set_debug_format` [deleted]

Synopses

Declared in <fmt/ostream.h>

template<typename Context>
decltype(ctx.out())
format(
    /* implementation-defined */ view,
    Context& ctx) const;

» more...

template<
    typename T,
    typename Context>
decltype(ctx.out())
format(
    T const& value,
    Context& ctx) const;

» more...

Synopsis

Declared in <fmt/ostream.h>

template<typename Context>
decltype(ctx.out())
format(
    /* implementation-defined */ view,
    Context& ctx) const;

Synopsis

Declared in <fmt/ostream.h>

template<
    typename T,
    typename Context>
decltype(ctx.out())
format(
    T const& value,
    Context& ctx) const;

Synopsis

Declared in <fmt/color.h>

template<
    typename T,
    typename Char>
struct formatter</* implementation-defined */, Char>
    : formatter<T, Char>

Base Classes

Name	Description
`formatter<T, Char>`

Member Functions

Name
`format`

Synopsis

Declared in <fmt/color.h>

template<typename FormatContext>
constexpr
decltype(ctx.out())
format(
    /* implementation-defined */ const& arg,
    FormatContext& ctx) const;

Synopsis

Declared in <fmt/chrono.h>

template<
    typename Char,
    typename Duration>
struct formatter<sys_time<Duration>, Char>;

Member Functions

Name
`format`
`parse`

Synopsis

Declared in <fmt/chrono.h>

template<typename FormatContext>
decltype(ctx.out())
format(
    sys_time<Duration> val,
    FormatContext& ctx) const;

Synopsis

Declared in <fmt/chrono.h>

constexpr
Char const*
parse(parse_context<Char>& ctx);

Synopsis

Declared in <fmt/ranges.h>

template<
    typename Tuple,
    typename Char>
requires is_tuple_like<Tuple>::value
struct formatter<tuple_join_view<Tuple, Char>, Char>;

Member Functions

Name
`format`
`parse`

Synopsis

Declared in <fmt/ranges.h>

template<typename FormatContext>
constexpr
FormatContext::iterator
format(
    tuple_join_view<Tuple, Char> const& value,
    FormatContext& ctx) const;

Synopsis

Declared in <fmt/ranges.h>

constexpr
Char const*
parse(parse_context<Char>& ctx);

Synopsis

Declared in <fmt/std.h>

template<
    int N,
    typename Char>
struct formatter</* implementation-defined */, Char>
    : formatter<long long, Char>

Base Classes

Name	Description
`formatter<long long, Char>`

Member Functions

Name
`format`

Static Member Functions

Name
`format_as`

Synopsis

Declared in <fmt/std.h>

template<typename Context>
decltype(ctx.out())
format(
    /* implementation-defined */ x,
    Context& ctx) const;

Synopsis

Declared in <fmt/std.h>

static
ullong
format_as(/* implementation-defined */ x);

Synopsis

Declared in <fmt/std.h>

template<
    typename E,
    typename Char>
requires is_formattable<E, Char>::value
struct formatter<std::unexpected<E>, Char>;

Member Functions

Name
`format`
`parse`

Synopsis

Declared in <fmt/std.h>

template<typename FormatContext>
decltype(ctx.out())
format(
    std::unexpected<E> const& value,
    FormatContext& ctx) const;

Synopsis

Declared in <fmt/std.h>

constexpr
Char const*
parse(parse_context<Char>& ctx);

Synopsis

Declared in <fmt/chrono.h>

template<
    typename Duration,
    typename Char>
struct formatter<utc_time<Duration>, Char>
    : formatter<sys_time<Duration>, Char>

Base Classes

Name	Description
`formatter<sys_time<Duration>, Char>`

Member Functions

Name
`format`

Synopsis

Declared in <fmt/chrono.h>

template<typename FormatContext>
decltype(ctx.out())
format(
    utc_time<Duration> val,
    FormatContext& ctx) const;

Synopsis

Declared in <fmt/format.h>

template<
    typename Char,
    size_t N>
struct formatter<Char[N], Char>
    : formatter<basic_string_view<Char>, Char>

Base Classes

Name	Description
`formatter<basic_string_view<Char>, Char>`

Synopsis

Declared in <fmt/format.h>

template<
    typename Char,
    typename Traits,
    typename Allocator>
class formatter<std::basic_string<Char, Traits, Allocator>, Char>
    : public formatter<basic_string_view<Char>, Char>

Base Classes

Name	Description
`formatter<basic_string_view<Char>, Char>`

Synopsis

Declared in <fmt/chrono.h>

template<
    typename Rep,
    typename Period,
    typename Char>
struct formatter<std::chrono::duration<Rep, Period>, Char>;

Member Functions

Name
`format`
`parse`

Synopsis

Declared in <fmt/chrono.h>

template<typename FormatContext>
decltype(ctx.out())
format(
    std::chrono::duration<Rep, Period> d,
    FormatContext& ctx) const;

Synopsis

Declared in <fmt/chrono.h>

constexpr
Char const*
parse(parse_context<Char>& ctx);

Synopsis

Declared in <fmt/std.h>

template<
    typename T,
    typename E,
    typename Char>
requires (std::is_void<T>::value ||
                                   is_formattable<T, Char>::value) &&
                                  is_formattable<E, Char>::value
struct formatter<std::expected<T, E>, Char>;

Member Functions

Name
`format`
`parse`

Synopsis

Declared in <fmt/std.h>

template<typename FormatContext>
decltype(ctx.out())
format(
    std::expected<T, E> const& value,
    FormatContext& ctx) const;

Synopsis

Declared in <fmt/std.h>

constexpr
Char const*
parse(parse_context<Char>& ctx);

Synopsis

Declared in <fmt/ranges.h>

template<
    typename It,
    typename Sentinel,
    typename Char>
struct formatter<join_view<It, Sentinel, Char>, Char>;

Type Aliases

Name
`nonlocking`

Member Functions

Name
`format`
`parse`

Synopsis

Declared in <fmt/ranges.h>

using nonlocking = void;

Synopsis

Declared in <fmt/ranges.h>

template<typename FormatContext>
constexpr
decltype(ctx.out())
format(
    view& value,
    FormatContext& ctx) const;

Synopsis

Declared in <fmt/ranges.h>

constexpr
Char const*
parse(parse_context<Char>& ctx);

Synopsis

Declared in <fmt/format.h>

template<
    typename T,
    typename Char>
struct formatter<T, Char, void_t</* implementation-defined */>>
    : formatter</* implementation-defined */, Char>

Base Classes

Name	Description
`formatter</* implementation-defined */, Char>`

Member Functions

Name
`format`

Synopsis

Declared in <fmt/format.h>

template<typename FormatContext>
constexpr
decltype(ctx.out())
format(
    T const& value,
    FormatContext& ctx) const;

Synopsis

Declared in <fmt/base.h>

template<typename... T>
struct fstring;

Type Aliases

Name
`t`

Member Functions

Name	Description
`fstring` [constructor]	Constructors
`get`
`operator string_view const&`	Conversion to `string_view`

Data Members

Name
`str`

Synopsis

Declared in <fmt/base.h>

using t = fstring;

Synopses

Declared in <fmt/base.h>

Construct from runtime_format_string

fstring(runtime_format_string<> fmt);

» more...

Construct from S

template<typename S>
[[always_inline]]
fstring(S const& value);

» more...

Construct from S

template<typename S>
[[always_inline]]
consteval
fstring(S const& s);

» more...

Construct from char

template<size_t N>
[[always_inline]]
consteval
fstring(char const(& s)[N]);

» more...

Synopsis

Declared in <fmt/base.h>

fstring(runtime_format_string<> fmt);

Parameters

Name	Description
fmt	The object to construct from

Synopsis

Declared in <fmt/base.h>

template<typename S>
[[always_inline]]
fstring(S const& value);

Parameters

Name	Description
value	The object to copy construct from

Synopsis

Declared in <fmt/base.h>

template<typename S>
[[always_inline]]
consteval
fstring(S const& s);

Parameters

Name	Description
s	The object to copy construct from

Synopsis

Declared in <fmt/base.h>

template<size_t N>
[[always_inline]]
consteval
fstring(char const(& s)[N]);

Parameters

Name	Description
s	The value to construct from

Synopsis

Declared in <fmt/base.h>

string_view
get() const;

Synopsis

Declared in <fmt/base.h>

[[deprecated]]
operator string_view const&() const;

Return Value

The object converted to string_view

Synopsis

Declared in <fmt/base.h>

string_view str;

Synopsis

Declared in <fmt/format.h>

template<
    typename OutputIt,
    typename Char>
class generic_context;

Type Aliases

Name
`char_type`
`iterator`

Enums

Name
`Unnamed enum`

Member Functions

Name	Description
`generic_context` [constructor] [deleted]	Constructors
`operator=` [deleted]
`advance_to`
`arg`
`arg_id`
`locale`
`out`

Synopsis

Declared in <fmt/format.h>

using char_type = Char;

Synopsis

Declared in <fmt/format.h>

using iterator = OutputIt;

Synopsis

Declared in <fmt/format.h>

enum Unnamed enum;

Members

Name
`builtin_types`

Synopses

Declared in <fmt/format.h>

Copy constructor

generic_context(generic_context const& other) = delete;

» more...

Move constructor

generic_context(generic_context&& other) = default;

» more...

constexpr
generic_context(
    OutputIt out,
    basic_format_args<generic_context> args,
    locale_ref loc = {});

» more...

Synopsis

Declared in <fmt/format.h>

generic_context(generic_context const& other) = delete;

Parameters

Name	Description
other	The object to copy construct from

Synopsis

Declared in <fmt/format.h>

generic_context(generic_context&& other) = default;

Parameters

Name	Description
other	The object to move construct from

Synopsis

Declared in <fmt/format.h>

constexpr
generic_context(
    OutputIt out,
    basic_format_args<generic_context> args,
    locale_ref loc = {});

Synopsis

Declared in <fmt/format.h>

void
operator=(generic_context const& other) = delete;

Synopsis

Declared in <fmt/format.h>

constexpr
void
advance_to(iterator it);

Synopses

Declared in <fmt/format.h>

constexpr
basic_format_arg<generic_context>
arg(int id) const;

» more...

basic_format_arg<generic_context>
arg(basic_string_view<Char> name) const;

» more...

Synopsis

Declared in <fmt/format.h>

constexpr
basic_format_arg<generic_context>
arg(int id) const;

Synopsis

Declared in <fmt/format.h>

basic_format_arg<generic_context>
arg(basic_string_view<Char> name) const;

Synopsis

Declared in <fmt/format.h>

constexpr
int
arg_id(basic_string_view<Char> name) const;

Synopsis

Declared in <fmt/format.h>

constexpr
locale_ref
locale() const;

Synopsis

Declared in <fmt/format.h>

constexpr
iterator
out() const;

Synopsis

Declared in <fmt/format.h>

template<typename T>
struct group_digits_view;

Data Members

Name
`value`

Non-Member Functions

Name	Description
`group_digits`	Returns a view that formats an integer value using ',' as a locale-independent thousands separator.

Synopsis

Declared in <fmt/format.h>

T value;

Synopsis

Declared in <fmt/compile.h>

template<typename S>
struct is_compiled_string
    : std::is_base_of<compiled_string, S>

Base Classes

Name	Description
`std::is_base_of<compiled_string, S>`

Synopsis

Declared in <fmt/ranges.h>

template<typename T>
struct is_container_adaptor;

Static Data Members

Name
`value`

Synopsis

Declared in <fmt/ranges.h>

inline constexpr static
bool value = !std::is_void<decltype(check<T>(nullptr))>::value;

Synopsis

Declared in <fmt/base.h>

template<typename T>
struct is_contiguous
    : /* implementation-defined */

Base Classes

Name	Description
`/* implementation-defined */`

Synopsis

Declared in <fmt/format.h>

template<
    typename T,
    size_t SIZE,
    typename Allocator>
struct is_contiguous<basic_memory_buffer<T, SIZE, Allocator>>
    : std::true_type

Base Classes

Name	Description
`std::true_type`

Synopsis

Declared in <fmt/format.h>

template<
    typename Char,
    typename Traits,
    typename Allocator>
struct is_contiguous<std::basic_string<Char, Traits, Allocator>>
    : std::true_type

Base Classes

Name	Description
`std::true_type`

Synopsis

Declared in <fmt/ranges.h>

template<
    typename T,
    typename Char>
struct is_range;

Static Data Members

Name
`value`

Synopsis

Declared in <fmt/ranges.h>

inline constexpr static
bool value = detail::is_range_<T>::value &&
                                !detail::is_optional_like_<T>::value &&
                                !detail::has_to_string_view<T>::value;

Synopsis

Declared in <fmt/ranges.h>

template<
    typename T,
    typename C>
struct is_tuple_formattable;

Static Data Members

Name
`value`

Synopsis

Declared in <fmt/ranges.h>

inline constexpr static
bool value = detail::is_tuple_formattable_<T, C>::value;

Synopsis

Declared in <fmt/ranges.h>

template<typename T>
struct is_tuple_like;

Static Data Members

Name
`value`

Synopsis

Declared in <fmt/ranges.h>

inline constexpr static
bool value = detail::is_tuple_like_<T>::value && !detail::is_range_<T>::value;

Synopsis

Declared in <fmt/std.h>

template<typename T>
struct is_tuple_like<std::complex<T>>
    : std::false_type

Base Classes

Name	Description
`std::false_type`

Synopsis

Declared in <fmt/std.h>

template<typename T>
struct is_variant_like;

Static Data Members

Name
`value`

Synopsis

Declared in <fmt/std.h>

inline constexpr static
bool value = detail::is_variant_like_<T>::value;

Synopsis

Declared in <fmt/ranges.h>

template<
    typename It,
    typename Sentinel,
    typename Char = char>
struct join_view
    : /* implementation-defined */

Base Classes

Name	Description
`/* implementation-defined */`

Member Functions

Name
`join_view` [constructor]

Data Members

Name
`begin`
`end`
`sep`

Non-Member Functions

Name	Description
`join`	Returns a view that formats the iterator range `[begin, end)]` with elements separated by `sep`.
`join`	Returns a view that formats `range` with elements separated by `sep`.
`join`	Returns an object that formats `std::initializer_list` with elements separated by `sep`.

Synopsis

Declared in <fmt/ranges.h>

constexpr
join_view(
    It b,
    Sentinel e,
    basic_string_view<Char> s);

Synopsis

Declared in <fmt/ranges.h>

It begin;

Synopsis

Declared in <fmt/ranges.h>

Sentinel end;

Synopsis

Declared in <fmt/ranges.h>

basic_string_view<Char> sep;

Synopsis

Declared in <fmt/format.h>

class loc_value;

Member Functions

Name	Description
`loc_value` [constructor]	Constructors
`visit`

Synopses

Declared in <fmt/format.h>

Construct from T

template<typename T>
loc_value(T value);

» more...

Construct from T

template<typename T>
loc_value(T value);

» more...

Synopsis

Declared in <fmt/format.h>

template<typename T>
loc_value(T value);

Parameters

Name	Description
value	The object to construct from

Synopsis

Declared in <fmt/format.h>

template<typename T>
loc_value(T value);

Parameters

Name	Description
value	The object to construct from

Synopsis

Declared in <fmt/format.h>

template<typename Visitor>
decltype(vis(0))
visit(Visitor&& vis);

Synopsis

Declared in <fmt/base.h>

class locale_ref;

Member Functions

Name	Description
`locale_ref` [constructor]	Constructors
`get`
`operator bool`	Conversion to `bool`

Synopses

Declared in <fmt/base.h>

Default constructor

constexpr
locale_ref();

» more...

Construct from Locale

template<typename Locale>
locale_ref(Locale const& loc);

» more...

Synopsis

Declared in <fmt/base.h>

constexpr
locale_ref();

Synopsis

Declared in <fmt/base.h>

template<typename Locale>
locale_ref(Locale const& loc);

Parameters

Name	Description
loc	The object to copy construct from

Synopsis

Declared in <fmt/base.h>

template<typename Locale>
Locale
get() const;

Synopsis

Declared in <fmt/base.h>

explicit
operator bool() const noexcept;

Return Value

The object converted to bool

Synopsis

Declared in <fmt/base.h>

template<
    typename T,
    typename Enable = void>
struct locking
    : std::false_type

Base Classes

Name	Description
`std::false_type`

Synopsis

Declared in <fmt/base.h>

struct monostate;

Member Functions

Name	Description
`monostate` [constructor]	Default constructor

Synopsis

Declared in <fmt/base.h>

constexpr
monostate();

Synopsis

Declared in <fmt/format.h>

template<
    typename T,
    typename Char = char>
struct nested_formatter;

Member Functions

Name	Description
`nested_formatter` [constructor]	Default constructor
`nested`
`parse`
`write_padded`

Derived Classes

Name	Description
`formatter<std::bitset<N>, Char>`

Synopsis

Declared in <fmt/format.h>

constexpr
nested_formatter();

Synopsis

Declared in <fmt/format.h>

nested_view<T, Char>
nested(T const& value) const;

Synopsis

Declared in <fmt/format.h>

constexpr
Char const*
parse(parse_context<Char>& ctx);

Synopsis

Declared in <fmt/format.h>

template<
    typename FormatContext,
    typename F>
decltype(ctx.out())
write_padded(
    FormatContext& ctx,
    F write) const;

Synopsis

Declared in <fmt/format.h>

template<
    typename T,
    typename Char>
struct nested_view;

Data Members

Name
`fmt`
`value`

Synopsis

Declared in <fmt/format.h>

formatter<T, Char> const* fmt;

Synopsis

Declared in <fmt/format.h>

T const* value;

Synopsis

Declared in <fmt/base.h>

template<typename Char = char>
class parse_context;

Type Aliases

Name
`char_type`
`iterator`

Member Functions

Name	Description
`parse_context` [constructor]
`advance_to`	Advances the begin iterator to `it`.
`begin`	Returns an iterator to the beginning of the format string range being parsed.
`check_arg_id`	Reports an error if using the automatic argument indexing; otherwise switches to the manual indexing.
`check_dynamic_spec`
`end`	Returns an iterator past the end of the format string range being parsed.
`next_arg_id`	Reports an error if using the manual argument indexing; otherwise returns the next argument index and switches to the automatic indexing.

Synopsis

Declared in <fmt/base.h>

using char_type = Char;

Synopsis

Declared in <fmt/base.h>

using iterator = Char const*;

Synopsis

Declared in <fmt/base.h>

constexpr
explicit
parse_context(
    basic_string_view<Char> fmt,
    int next_arg_id = 0);

Synopsis

Declared in <fmt/base.h>

constexpr
void
advance_to(iterator it);

Synopsis

Declared in <fmt/base.h>

constexpr
iterator
begin() const noexcept;

Synopses

Declared in <fmt/base.h>

Reports an error if using the automatic argument indexing; otherwise switches to the manual indexing.

constexpr
void
check_arg_id(int id);

» more...

constexpr
void
check_arg_id(basic_string_view<Char>);

» more...

Synopsis

Declared in <fmt/base.h>

constexpr
void
check_arg_id(int id);

Synopsis

Declared in <fmt/base.h>

constexpr
void
check_arg_id(basic_string_view<Char>);

Synopsis

Declared in <fmt/base.h>

constexpr
void
check_dynamic_spec(int arg_id);

Synopsis

Declared in <fmt/base.h>

constexpr
iterator
end() const noexcept;

Return Value

an iterator past the end of the format string range being parsed.

Synopsis

Declared in <fmt/base.h>

constexpr
int
next_arg_id();

Synopsis

Declared in <fmt/base.h>

template<>
class parse_context<char>;

Type Aliases

Name
`char_type`
`iterator`

Member Functions

Name
`parse_context` [constructor]
`advance_to`
`begin`
`check_arg_id`
`check_dynamic_spec`
`end`
`next_arg_id`

Synopsis

Declared in <fmt/base.h>

using char_type = char;

Synopsis

Declared in <fmt/base.h>

using iterator = char const*;

Synopsis

Declared in <fmt/base.h>

constexpr
explicit
parse_context(
    basic_string_view<char> fmt,
    int next_arg_id = 0);

Synopsis

Declared in <fmt/base.h>

constexpr
void
advance_to(iterator it);

Synopsis

Declared in <fmt/base.h>

constexpr
iterator
begin() const noexcept;

Synopses

Declared in <fmt/base.h>

constexpr
void
check_arg_id(int id);

» more...

constexpr
void
check_arg_id(basic_string_view<char>);

» more...

Synopsis

Declared in <fmt/base.h>

constexpr
void
check_arg_id(int id);

Synopsis

Declared in <fmt/base.h>

constexpr
void
check_arg_id(basic_string_view<char>);

Synopsis

Declared in <fmt/base.h>

constexpr
void
check_dynamic_spec(int arg_id);

Synopsis

Declared in <fmt/base.h>

constexpr
iterator
end() const noexcept;

Synopsis

Declared in <fmt/base.h>

constexpr
int
next_arg_id();

Synopsis

Declared in <fmt/std.h>

class path
    : public std::filesystem::path

Base Classes

Name	Description
`std::filesystem::path`

Types

Name
`iterator`

Type Aliases

Name
`const_iterator`
`string_type`
`value_type`

Enums

Name	Description
`format`	path::format is ignored in this implementation

Member Functions

Name	Description
`operator=`	Assignment operators
`append`
`assign`
`begin`
`c_str`
`clear`
`compare`
`concat`
`display_string`
`empty`
`end`
`extension`
`filename`
`generic_display_string`
`generic_string`
`generic_system_string`
`generic_u16string`
`generic_u32string`
`generic_u8string`
`generic_wstring`
`has_extension`
`has_filename`
`has_parent_path`
`has_relative_path`
`has_root_directory`
`has_root_name`
`has_root_path`
`has_stem`
`is_absolute`
`is_relative`
`lexically_normal`
`lexically_proximate`
`lexically_relative`
`make_preferred`
`native`
`operator+=`	Addition assignment operators
`operator/=`	Division assignment operators
`parent_path`
`relative_path`
`remove_filename`
`replace_extension`
`replace_filename`
`root_directory`
`root_name`
`root_path`
`stem`
`string`
`swap`
`system_string`
`u16string`
`u32string`
`u8string`
`wstring`
`operator string_type`	Conversion to `string_type`

Static Data Members

Name
`preferred_separator`

Synopsis

Declared in <bits/fs_path.h>

using const_iterator = iterator;

Synopsis

Declared in <bits/fs_path.h>

using string_type = std::basic_string<value_type>;

Synopsis

Declared in <bits/fs_path.h>

using value_type = char;

Synopsis

Declared in <bits/fs_path.h>

class iterator;

Friends

Name	Description
`std::filesystem::__path_iter_advance`
`std::filesystem::__path_iter_distance`
`std::filesystem::path`
`std::filesystem::operator!=`
`std::filesystem::operator==`

Synopsis

Declared in <bits/fs_path.h>

enum format : unsigned char;

Synopses

Declared in <bits/fs_path.h>

path&
operator=(path const& value);

» more...

path&
operator=(path&& value) noexcept;

» more...

path&
operator=(string_type&& __source);

» more...

template<typename _Source>
__detail::_Path<_Source>&
operator=(_Source const& __source);

» more...

Synopsis

Declared in <bits/fs_path.h>

path&
operator=(path const& value);

Synopsis

Declared in <bits/fs_path.h>

path&
operator=(path&& value) noexcept;

Synopsis

Declared in <bits/fs_path.h>

path&
operator=(string_type&& __source);

Synopsis

Declared in <bits/fs_path.h>

template<typename _Source>
__detail::_Path<_Source>&
operator=(_Source const& __source);

Synopses

Declared in <bits/fs_path.h>

template<typename _Source>
__detail::_Path<_Source>&
append(_Source const& __source);

» more...

template<typename _InputIterator>
__detail::_Path2<_InputIterator>&
append(
    _InputIterator __first,
    _InputIterator __last);

» more...

Synopsis

Declared in <bits/fs_path.h>

template<typename _Source>
__detail::_Path<_Source>&
append(_Source const& __source);

Synopsis

Declared in <bits/fs_path.h>

template<typename _InputIterator>
__detail::_Path2<_InputIterator>&
append(
    _InputIterator __first,
    _InputIterator __last);

Synopses

Declared in <bits/fs_path.h>

path&
assign(string_type&& __source);

» more...

template<typename _Source>
__detail::_Path<_Source>&
assign(_Source const& __source);

» more...

template<typename _InputIterator>
__detail::_Path2<_InputIterator>&
assign(
    _InputIterator __first,
    _InputIterator __last);

» more...

Synopsis

Declared in <bits/fs_path.h>

path&
assign(string_type&& __source);

Synopsis

Declared in <bits/fs_path.h>

template<typename _Source>
__detail::_Path<_Source>&
assign(_Source const& __source);

Synopsis

Declared in <bits/fs_path.h>

template<typename _InputIterator>
__detail::_Path2<_InputIterator>&
assign(
    _InputIterator __first,
    _InputIterator __last);

Synopsis

Declared in <bits/fs_path.h>

iterator
begin() const noexcept;

Synopsis

Declared in <bits/fs_path.h>

value_type const*
c_str() const noexcept;

Synopsis

Declared in <bits/fs_path.h>

void
clear() noexcept;

Synopses

Declared in <bits/fs_path.h>

int
compare(basic_string_view<value_type> __s) const noexcept;

» more...

int
compare(path const& __p) const noexcept;

» more...

int
compare(string_type const& __s) const noexcept;

» more...

int
compare(value_type const* __s) const noexcept;

» more...

Synopsis

Declared in <bits/fs_path.h>

int
compare(basic_string_view<value_type> __s) const noexcept;

Synopsis

Declared in <bits/fs_path.h>

int
compare(path const& __p) const noexcept;

Synopsis

Declared in <bits/fs_path.h>

int
compare(string_type const& __s) const noexcept;

Synopsis

Declared in <bits/fs_path.h>

int
compare(value_type const* __s) const noexcept;

Synopses

Declared in <bits/fs_path.h>

template<typename _Source>
__detail::_Path<_Source>&
concat(_Source const& __x);

» more...

template<typename _InputIterator>
__detail::_Path2<_InputIterator>&
concat(
    _InputIterator __first,
    _InputIterator __last);

» more...

Synopsis

Declared in <bits/fs_path.h>

template<typename _Source>
__detail::_Path<_Source>&
concat(_Source const& __x);

Synopsis

Declared in <bits/fs_path.h>

template<typename _InputIterator>
__detail::_Path2<_InputIterator>&
concat(
    _InputIterator __first,
    _InputIterator __last);

Synopsis

Declared in <fmt/std.h>

std::string
display_string() const;

Synopsis

Declared in <bits/fs_path.h>

[[nodiscard]]
bool
empty() const noexcept;

Synopsis

Declared in <bits/fs_path.h>

iterator
end() const noexcept;

Synopsis

Declared in <bits/fs_path.h>

path
extension() const;

Synopsis

Declared in <bits/fs_path.h>

path
filename() const;

Synopsis

Declared in <fmt/std.h>

std::string
generic_display_string() const;

Synopses

Declared in <bits/fs_path.h>

std::string
generic_string() const;

» more...

template<
    typename _CharT,
    typename _Traits = std::char_traits<_CharT>,
    typename _Allocator = std::allocator<_CharT>>
std::basic_string<_CharT, _Traits, _Allocator>
generic_string(_Allocator const& __a = _Allocator()) const;

» more...

Synopsis

Declared in <bits/fs_path.h>

std::string
generic_string() const;

Synopsis

Declared in <bits/fs_path.h>

template<
    typename _CharT,
    typename _Traits = std::char_traits<_CharT>,
    typename _Allocator = std::allocator<_CharT>>
std::basic_string<_CharT, _Traits, _Allocator>
generic_string(_Allocator const& __a = _Allocator()) const;

Synopsis

Declared in <fmt/std.h>

std::string
generic_system_string() const;

Synopsis

Declared in <bits/fs_path.h>

std::u16string
generic_u16string() const;

Synopsis

Declared in <bits/fs_path.h>

std::u32string
generic_u32string() const;

Synopsis

Declared in <bits/fs_path.h>

[[__abi_tag__]]
std::u8string
generic_u8string() const;

Synopsis

Declared in <bits/fs_path.h>

std::wstring
generic_wstring() const;

Synopsis

Declared in <bits/fs_path.h>

bool
has_extension() const noexcept;

Synopsis

Declared in <bits/fs_path.h>

bool
has_filename() const noexcept;

Synopsis

Declared in <bits/fs_path.h>

bool
has_parent_path() const noexcept;

Synopsis

Declared in <bits/fs_path.h>

bool
has_relative_path() const noexcept;

Synopsis

Declared in <bits/fs_path.h>

bool
has_root_directory() const noexcept;

Synopsis

Declared in <bits/fs_path.h>

bool
has_root_name() const noexcept;

Synopsis

Declared in <bits/fs_path.h>

bool
has_root_path() const noexcept;

Synopsis

Declared in <bits/fs_path.h>

bool
has_stem() const noexcept;

Synopsis

Declared in <bits/fs_path.h>

bool
is_absolute() const noexcept;

Synopsis

Declared in <bits/fs_path.h>

bool
is_relative() const noexcept;

Synopsis

Declared in <bits/fs_path.h>

path
lexically_normal() const;

Synopsis

Declared in <bits/fs_path.h>

path
lexically_proximate(path const& base) const;

Synopsis

Declared in <bits/fs_path.h>

path
lexically_relative(path const& base) const;

Synopsis

Declared in <bits/fs_path.h>

path&
make_preferred();

Synopsis

Declared in <bits/fs_path.h>

string_type const&
native() const noexcept;

Synopses

Declared in <bits/fs_path.h>

path&
operator+=(value_type __x);

» more...

path&
operator+=(basic_string_view<value_type> __x);

» more...

path&
operator+=(path const& __x);

» more...

path&
operator+=(string_type const& __x);

» more...

path&
operator+=(value_type const* __x);

» more...

template<typename _CharT>
__detail::_Path2<_CharT*>&
operator+=(_CharT __x);

» more...

template<typename _Source>
__detail::_Path<_Source>&
operator+=(_Source const& __x);

» more...

Synopsis

Declared in <bits/fs_path.h>

path&
operator+=(value_type __x);

Synopsis

Declared in <bits/fs_path.h>

path&
operator+=(basic_string_view<value_type> __x);

Synopsis

Declared in <bits/fs_path.h>

path&
operator+=(path const& __x);

Synopsis

Declared in <bits/fs_path.h>

path&
operator+=(string_type const& __x);

Synopsis

Declared in <bits/fs_path.h>

path&
operator+=(value_type const* __x);

Synopsis

Declared in <bits/fs_path.h>

template<typename _CharT>
__detail::_Path2<_CharT*>&
operator+=(_CharT __x);

Synopsis

Declared in <bits/fs_path.h>

template<typename _Source>
__detail::_Path<_Source>&
operator+=(_Source const& __x);

Synopses

Declared in <bits/fs_path.h>

path&
operator/=(path const& __p);

» more...

template<typename _Source>
__detail::_Path<_Source>&
operator/=(_Source const& __source);

» more...

Synopsis

Declared in <bits/fs_path.h>

path&
operator/=(path const& __p);

Synopsis

Declared in <bits/fs_path.h>

template<typename _Source>
__detail::_Path<_Source>&
operator/=(_Source const& __source);

Synopsis

Declared in <bits/fs_path.h>

path
parent_path() const;

Synopsis

Declared in <bits/fs_path.h>

path
relative_path() const;

Synopsis

Declared in <bits/fs_path.h>

path&
remove_filename();

Synopsis

Declared in <bits/fs_path.h>

path&
replace_extension(path const& __replacement = path());

Synopsis

Declared in <bits/fs_path.h>

path&
replace_filename(path const& __replacement);

Synopsis

Declared in <bits/fs_path.h>

path
root_directory() const;

Synopsis

Declared in <bits/fs_path.h>

path
root_name() const;

Synopsis

Declared in <bits/fs_path.h>

path
root_path() const;

Synopsis

Declared in <bits/fs_path.h>

path
stem() const;

Synopses

Declared in <bits/fs_path.h>

std::string
string() const;

» more...

template<
    typename _CharT,
    typename _Traits = std::char_traits<_CharT>,
    typename _Allocator = std::allocator<_CharT>>
std::basic_string<_CharT, _Traits, _Allocator>
string(_Allocator const& __a = _Allocator()) const;

» more...

Synopsis

Declared in <bits/fs_path.h>

std::string
string() const;

Synopsis

Declared in <bits/fs_path.h>

template<
    typename _CharT,
    typename _Traits = std::char_traits<_CharT>,
    typename _Allocator = std::allocator<_CharT>>
std::basic_string<_CharT, _Traits, _Allocator>
string(_Allocator const& __a = _Allocator()) const;

Synopsis

Declared in <bits/fs_path.h>

void
swap(path& __rhs) noexcept;

Synopsis

Declared in <fmt/std.h>

std::string
system_string() const;

Synopsis

Declared in <bits/fs_path.h>

std::u16string
u16string() const;

Synopsis

Declared in <bits/fs_path.h>

std::u32string
u32string() const;

Synopsis

Declared in <bits/fs_path.h>

[[__abi_tag__]]
std::u8string
u8string() const;

Synopsis

Declared in <bits/fs_path.h>

std::wstring
wstring() const;

Synopsis

Declared in <bits/fs_path.h>

operator string_type() const;

Return Value

The object converted to string_type

Synopsis

Declared in <bits/fs_path.h>

inline constexpr static
value_type preferred_separator = '/';

Synopsis

Declared in <fmt/ranges.h>

template<
    typename T,
    typename Char,
    typename Enable = void>
struct range_format_kind
    : conditional_t<is_range<T, Char>::value, /* implementation-defined */, std::integral_constant<range_format, range_format::disabled>>

Base Classes

Name	Description
`conditional_t<is_range<T, Char>::value, /* implementation-defined */, std::integral_constant<range_format, range_format::disabled>>`

Synopsis

Declared in <fmt/ranges.h>

template<
    typename T,
    typename Char,
    typename Enable = void>
struct range_formatter;

Synopsis

Declared in <fmt/ranges.h>

template<
    typename T,
    typename Char>
requires conjunction<std::is_same<T, remove_cvref_t<T>>,
                            is_formattable<T, Char>>::value
struct range_formatter<T, Char>;

Member Functions

Name	Description
`range_formatter` [constructor]	Default constructor
`format`
`parse`
`set_brackets`
`set_separator`
`underlying`

Synopsis

Declared in <fmt/ranges.h>

constexpr
range_formatter();

Synopsis

Declared in <fmt/ranges.h>

template<
    typename R,
    typename FormatContext>
constexpr
decltype(ctx.out())
format(
    R&& range,
    FormatContext& ctx) const;

Synopsis

Declared in <fmt/ranges.h>

constexpr
Char const*
parse(parse_context<Char>& ctx);

Synopsis

Declared in <fmt/ranges.h>

constexpr
void
set_brackets(
    basic_string_view<Char> open,
    basic_string_view<Char> close);

Synopsis

Declared in <fmt/ranges.h>

constexpr
void
set_separator(basic_string_view<Char> sep);

Synopsis

Declared in <fmt/ranges.h>

constexpr
/* implementation-defined */&
underlying();

Synopsis

Declared in <fmt/color.h>

struct rgb;

Member Functions

Name	Description
`rgb` [constructor]	Constructors

Data Members

Name
`b`
`g`
`r`

Synopses

Declared in <fmt/color.h>

Default constructor

constexpr
rgb();

» more...

Construct from color

constexpr
rgb(color hex);

» more...

Construct from uint32_t

constexpr
rgb(uint32_t hex);

» more...

constexpr
rgb(
    uint8_t r_,
    uint8_t g_,
    uint8_t b_);

» more...

Synopsis

Declared in <fmt/color.h>

constexpr
rgb();

Synopsis

Declared in <fmt/color.h>

constexpr
rgb(color hex);

Parameters

Name	Description
hex	The object to construct from

Synopsis

Declared in <fmt/color.h>

constexpr
rgb(uint32_t hex);

Parameters

Name	Description
hex	The object to construct from

Synopsis

Declared in <fmt/color.h>

constexpr
rgb(
    uint8_t r_,
    uint8_t g_,
    uint8_t b_);

Synopsis

Declared in <fmt/color.h>

uint8_t b;

Synopsis

Declared in <fmt/color.h>

uint8_t g;

Synopsis

Declared in <fmt/color.h>

uint8_t r;

Synopsis

Declared in <fmt/base.h>

template<typename Char = char>
struct runtime_format_string;

Data Members

Name
`str`

Non-Member Functions

Name	Description
`runtime`	Creates a runtime format string.

Synopsis

Declared in <fmt/base.h>

basic_string_view<Char> str;

Synopsis

Declared in <fmt/compile.h>

template<size_t N>
class static_format_result;

Member Functions

Name
`static_format_result` [constructor]
`c_str`
`str`

Synopsis

Declared in <fmt/compile.h>

template<
    typename S,
    typename... T>
constexpr
explicit
static_format_result(
    S const& fmt,
    T&&... args);

Synopsis

Declared in <fmt/compile.h>

constexpr
char const*
c_str() const;

Synopsis

Declared in <fmt/compile.h>

constexpr
fmt::string_view
str() const;

Synopsis

Declared in <fmt/format.h>

class string_buffer;

Member Functions

Name	Description
`string_buffer` [constructor]	Default constructor
`str`
`operator writer`	Conversion to `writer`

Synopsis

Declared in <fmt/format.h>

string_buffer();

Synopsis

Declared in <fmt/format.h>

std::string&
str();

Synopsis

Declared in <fmt/format.h>

operator writer();

Return Value

The object converted to writer

Synopsis

Declared in <fmt/color.h>

class text_style;

Member Functions

Name	Description
`text_style` [constructor]	Default constructor
`get_background`
`get_emphasis`
`get_foreground`
`has_background`
`has_emphasis`
`has_foreground`
`operator\|=`	Bitwise disjunction assignment operator
`operator==`	Equality operator
`operator!=`	Inequality operator

Friends

Name	Description
`fmt::bg`	Creates a text style from the background color.
`fmt::fg`	Creates a text style from the foreground (text) color.
`fmt::operator\|`	Bitwise disjunction operator

Non-Member Functions

Name	Description
`format`	Formats arguments and returns the result as a string using ANSI escape sequences to specify text formatting.
`operator\|`	Bitwise disjunction operator
`print`	Formats a string and prints it to stdout using ANSI escape sequences to specify text formatting.
`println`	Formats a string and prints it to stdout followed by a newline, using ANSI escape sequences to specify text formatting.

Synopsis

Declared in <fmt/color.h>

constexpr
text_style(emphasis em = emphasis()) noexcept;

Parameters

Name	Description
em	The object to construct from

Synopsis

Declared in <fmt/color.h>

constexpr
/* implementation-defined */
get_background() const noexcept;

Synopsis

Declared in <fmt/color.h>

constexpr
emphasis
get_emphasis() const noexcept;

Synopsis

Declared in <fmt/color.h>

constexpr
/* implementation-defined */
get_foreground() const noexcept;

Synopsis

Declared in <fmt/color.h>

constexpr
bool
has_background() const noexcept;

Synopsis

Declared in <fmt/color.h>

constexpr
bool
has_emphasis() const noexcept;

Synopsis

Declared in <fmt/color.h>

constexpr
bool
has_foreground() const noexcept;

Synopsis

Declared in <fmt/color.h>

constexpr
text_style&
operator|=(text_style rhs);

Return Value

Reference to the current object

Parameters

Name	Description
rhs	The right operand

Synopsis

Declared in <fmt/color.h>

constexpr
bool
operator==(text_style rhs) const noexcept;

Return Value

true if the objects are equal, false otherwise

Parameters

Name	Description
rhs	The right operand

Synopsis

Declared in <fmt/color.h>

constexpr
bool
operator!=(text_style rhs) const noexcept;

Return Value

true if the objects are not equal, false otherwise

Parameters

Name	Description
rhs	The right operand

Synopsis

Declared in <fmt/ranges.h>

template<
    typename Tuple,
    typename Char>
struct tuple_join_view
    : /* implementation-defined */

Base Classes

Name	Description
`/* implementation-defined */`

Member Functions

Name	Description
`tuple_join_view` [constructor]	Constructor

Data Members

Name
`sep`
`tuple`

Non-Member Functions

Name	Description
`join`	Returns an object that formats `std::tuple` with elements separated by `sep`.

Synopsis

Declared in <fmt/ranges.h>

constexpr
tuple_join_view(
    Tuple const& t,
    basic_string_view<Char> s);

Parameters

Name	Description
t	The object to copy construct from
s	An implementation of `std::basic_string_view` for pre-C++17 providing a subset of the API. `fmt::basic_string_view` is used in the public API even if `std::basic_string_view` is available to prevent issues when a library is compiled with a different `-std` option than the client code (which is not recommended).

Synopsis

Declared in <fmt/ranges.h>

basic_string_view<Char> sep;

Synopsis

Declared in <fmt/ranges.h>

Tuple const& tuple;

Synopsis

Declared in <fmt/printf.h>

template<typename Char>
struct vprintf_args;

Type Aliases

Name
`type`

Synopsis

Declared in <fmt/printf.h>

using type = basic_format_args<basic_printf_context<Char>>;

Synopsis

Declared in <fmt/format.h>

class writer;

Member Functions

Name	Description
`writer` [constructor]	Constructors
`print`	Formats `args` according to specifications in `fmt` and writes the output to the file.

Synopses

Declared in <fmt/format.h>

Construct from buffer

writer(/* implementation-defined */& buf);

» more...

Construct from FILE

writer(FILE* f);

» more...

Synopsis

Declared in <fmt/format.h>

writer(/* implementation-defined */& buf);

Parameters

Name	Description
buf	The object to copy construct from

Synopsis

Declared in <fmt/format.h>

writer(FILE* f);

Parameters

Name	Description
f	The object to construct from

Synopsis

Declared in <fmt/format.h>

template<typename... T>
void
print(
    format_string<T...> fmt,
    T&&... args);

Synopsis

Declared in <fmt/format.h>

enum Unnamed enum;

Members

Name
`inline_buffer_size`

Synopsis

Declared in <fmt/base.h>

enum class align : int;

Members

Name
`none`
`left`
`right`
`center`
`numeric`

Synopsis

Declared in <fmt/base.h>

enum class arg_id_kind : int;

Members

Name
`none`
`index`
`name`

Synopsis

Declared in <fmt/color.h>

enum class color : uint32_t;

Members

Name
`alice_blue`
`antique_white`
`aqua`
`aquamarine`
`azure`
`beige`
`bisque`
`black`
`blanched_almond`
`blue`
`blue_violet`
`brown`
`burly_wood`
`cadet_blue`
`chartreuse`
`chocolate`
`coral`
`cornflower_blue`
`cornsilk`
`crimson`
`cyan`
`dark_blue`
`dark_cyan`
`dark_golden_rod`
`dark_gray`
`dark_green`
`dark_khaki`
`dark_magenta`
`dark_olive_green`
`dark_orange`
`dark_orchid`
`dark_red`
`dark_salmon`
`dark_sea_green`
`dark_slate_blue`
`dark_slate_gray`
`dark_turquoise`
`dark_violet`
`deep_pink`
`deep_sky_blue`
`dim_gray`
`dodger_blue`
`fire_brick`
`floral_white`
`forest_green`
`fuchsia`
`gainsboro`
`ghost_white`
`gold`
`golden_rod`
`gray`
`green`
`green_yellow`
`honey_dew`
`hot_pink`
`indian_red`
`indigo`
`ivory`
`khaki`
`lavender`
`lavender_blush`
`lawn_green`
`lemon_chiffon`
`light_blue`
`light_coral`
`light_cyan`
`light_golden_rod_yellow`
`light_gray`
`light_green`
`light_pink`
`light_salmon`
`light_sea_green`
`light_sky_blue`
`light_slate_gray`
`light_steel_blue`
`light_yellow`
`lime`
`lime_green`
`linen`
`magenta`
`maroon`
`medium_aquamarine`
`medium_blue`
`medium_orchid`
`medium_purple`
`medium_sea_green`
`medium_slate_blue`
`medium_spring_green`
`medium_turquoise`
`medium_violet_red`
`midnight_blue`
`mint_cream`
`misty_rose`
`moccasin`
`navajo_white`
`navy`
`old_lace`
`olive`
`olive_drab`
`orange`
`orange_red`
`orchid`
`pale_golden_rod`
`pale_green`
`pale_turquoise`
`pale_violet_red`
`papaya_whip`
`peach_puff`
`peru`
`pink`
`plum`
`powder_blue`
`purple`
`rebecca_purple`
`red`
`rosy_brown`
`royal_blue`
`saddle_brown`
`salmon`
`sandy_brown`
`sea_green`
`sea_shell`
`sienna`
`silver`
`sky_blue`
`slate_blue`
`slate_gray`
`snow`
`spring_green`
`steel_blue`
`tan`
`teal`
`thistle`
`tomato`
`turquoise`
`violet`
`wheat`
`white`
`white_smoke`
`yellow`
`yellow_green`

Synopsis

Declared in <fmt/color.h>

enum class emphasis : uint8_t;

Members

Name
`bold`
`faint`
`italic`
`underline`
`blink`
`reverse`
`conceal`
`strikethrough`

Non-Member Functions

Name	Description
`operator\|`	Bitwise disjunction operator

Synopsis

Declared in <fmt/base.h>

enum class presentation_type : unsigned char;

Members

Name
`none`
`debug`
`string`
`dec`
`hex`
`oct`
`bin`
`chr`
`pointer`
`exp`
`fixed`
`general`
`hexfloat`

Synopsis

Declared in <fmt/ranges.h>

enum class range_format : int;

Members

Name
`disabled`
`map`
`set`
`sequence`
`string`
`debug_string`

Synopsis

Declared in <fmt/base.h>

enum class sign : int;

Members

Name
`none`
`minus`
`plus`
`space`

Synopsis

Declared in <fmt/color.h>

enum class terminal_color : uint8_t;

Members

Name
`black`
`red`
`green`
`yellow`
`blue`
`magenta`
`cyan`
`white`
`bright_black`
`bright_red`
`bright_green`
`bright_yellow`
`bright_blue`
`bright_magenta`
`bright_cyan`
`bright_white`

Synopses

Declared in <fmt/compile.h>

User-defined literal equivalent of fmt::arg, but with compile-time checks.

template</* implementation-defined */ S>
constexpr
auto
Unnamed function();

» more...

template</* implementation-defined */ Str>
constexpr
auto
Unnamed function();

» more...

Synopsis

Declared in <fmt/format.h>

template</* implementation-defined */ S>
constexpr
auto
Unnamed function();

Description

Example:

using namespace fmt::literals; fmt::print("The answer is {answer}.", "answer"_a=42);

Synopsis

Declared in <fmt/compile.h>

template</* implementation-defined */ Str>
constexpr
auto
Unnamed function();

Synopses

Declared in <fmt/base.h>

Returns a named argument to be used in a formatting function. It should only be used in a call to a formatting function.

template<typename T>
named_arg<T>
arg(
    char const* name,
    T const& arg);

» more...

template<typename T>
named_arg<T, wchar_t>
arg(
    wchar_t const* name,
    T const& arg);

» more...

Synopsis

Declared in <fmt/base.h>

template<typename T>
named_arg<T>
arg(
    char const* name,
    T const& arg);

Description

Example:

fmt::print("The answer is {answer}.", fmt::arg("answer", 42));

Named arguments passed with fmt::arg are not supported in compile-time checks, but "answer"_a=42 are compile-time checked in sufficiently new compilers. See operator""_a().

Synopsis

Declared in <fmt/xchar.h>

template<typename T>
named_arg<T, wchar_t>
arg(
    wchar_t const* name,
    T const& arg);

Synopsis

Declared in <fmt/base.h>

[[noreturn]]
void
assert_fail(
    char const* file,
    int line,
    char const* message);

Synopsis

Declared in <fmt/color.h>

constexpr
text_style
bg(/* implementation-defined */ background) noexcept;

Return Value

A text style consisting of foreground and background colors and emphasis.

Synopsis

Declared in <fmt/color.h>

constexpr
text_style
fg(/* implementation-defined */ foreground) noexcept;

Return Value

A text style consisting of foreground and background colors and emphasis.

Synopses

Declared in <fmt/color.h>

Formats args according to specifications in fmt and returns the result as a string.

template<typename... T>
[[nodiscard]]
std::string
format(
    format_string<T...> fmt,
    T&&... args);

» more...

template<typename... T>
std::wstring
format(
    wformat_string<T...> fmt,
    T&&... args);

» more...

template<
    typename S,
    typename... T>
constexpr
std::basic_string<S::char_type>
format(
    S const&,
    T&&... args);

» more...

template<
    typename CompiledFormat,
    typename... T,
    typename Char = CompiledFormat::char_type>
constexpr
std::basic_string<Char>
format(
    CompiledFormat const& cf,
    T const&... args);

» more...

template<
    typename S,
    typename... T,
    typename Char = /* implementation-defined */>
std::basic_string<Char>
format(
    S const& fmt,
    T&&... args);

» more...

template<typename... T>
std::string
format(
    locale_ref loc,
    format_string<T...> fmt,
    T&&... args);

» more...

Formats arguments and returns the result as a string using ANSI escape sequences to specify text formatting.

template<typename... T>
std::string
format(
    text_style ts,
    format_string<T...> fmt,
    T&&... args);

» more...

template<typename... T>
std::wstring
format(
    text_style ts,
    wformat_string<T...> fmt,
    T&&... args);

» more...

template<
    typename S,
    typename... T,
    typename Char = /* implementation-defined */>
std::basic_string<Char>
format(
    locale_ref loc,
    S const& fmt,
    T&&... args);

» more...

Synopsis

Declared in <fmt/format.h>

template<typename... T>
[[nodiscard]]
std::string
format(
    format_string<T...> fmt,
    T&&... args);

Description

Example:

#include <fmt/format.h> std::string message = fmt::format("The answer is {}.", 42);

Synopsis

Declared in <fmt/xchar.h>

template<typename... T>
std::wstring
format(
    wformat_string<T...> fmt,
    T&&... args);

Synopsis

Declared in <fmt/compile.h>

template<
    typename S,
    typename... T>
constexpr
std::basic_string<S::char_type>
format(
    S const&,
    T&&... args);

Synopsis

Declared in <fmt/compile.h>

template<
    typename CompiledFormat,
    typename... T,
    typename Char = CompiledFormat::char_type>
constexpr
std::basic_string<Char>
format(
    CompiledFormat const& cf,
    T const&... args);

Synopsis

Declared in <fmt/xchar.h>

template<
    typename S,
    typename... T,
    typename Char = /* implementation-defined */>
std::basic_string<Char>
format(
    S const& fmt,
    T&&... args);

Synopsis

Declared in <fmt/format.h>

template<typename... T>
std::string
format(
    locale_ref loc,
    format_string<T...> fmt,
    T&&... args);

Synopsis

Declared in <fmt/color.h>

template<typename... T>
std::string
format(
    text_style ts,
    format_string<T...> fmt,
    T&&... args);

Description

Example:

` #include <fmt/color.h> std::string message = fmt::format(fmt::emphasis::bold | fg(fmt::color::red), "The answer is {}", 42); `

Parameters

Name	Description
ts	A text style consisting of foreground and background colors and emphasis.

Synopsis

Declared in <fmt/xchar.h>

template<typename... T>
std::wstring
format(
    text_style ts,
    wformat_string<T...> fmt,
    T&&... args);

Synopsis

Declared in <fmt/xchar.h>

template<
    typename S,
    typename... T,
    typename Char = /* implementation-defined */>
std::basic_string<Char>
format(
    locale_ref loc,
    S const& fmt,
    T&&... args);

Synopsis

Declared in <fmt/format.h>

void
format_system_error(
    /* implementation-defined */& out,
    int error_code,
    char const* message) noexcept;

Description

where <message> is the passed message and <system-message> is the system message corresponding to the error code. error_code is a system error code as given by errno.

Parameters

Name	Description
out	A contiguous memory buffer with an optional growing ability. It is an internal class and shouldn't be used directly, only via `memory_buffer`.

Synopses

Declared in <fmt/base.h>

template<
    typename OutputIt,
    typename... T>
OutputIt
format_to(
    OutputIt out,
    wformat_string<T...> fmt,
    T&&... args);

» more...

template<
    size_t N,
    typename... T>
format_to_result
format_to(
    char(& out)[N],
    format_string<T...> fmt,
    T&&... args);

» more...

Formats args according to specifications in fmt, writes the result to the output iterator out and returns the iterator past the end of the output range. format_to does not append a terminating null character.

template<
    typename OutputIt,
    typename... T>
remove_cvref_t<OutputIt>
format_to(
    OutputIt&& out,
    format_string<T...> fmt,
    T&&... args);

» more...

template<
    typename OutputIt,
    typename CompiledFormat,
    typename... T>
constexpr
OutputIt
format_to(
    OutputIt out,
    CompiledFormat const& cf,
    T const&... args);

» more...

template<
    typename OutputIt,
    typename S,
    typename... T>
constexpr
OutputIt
format_to(
    OutputIt out,
    S const&,
    T&&... args);

» more...

template<
    typename OutputIt,
    typename S,
    typename... T,
    typename Char = /* implementation-defined */>
OutputIt
format_to(
    OutputIt out,
    S const& fmt,
    T&&... args);

» more...

template<
    typename OutputIt,
    typename... T>
OutputIt
format_to(
    OutputIt out,
    locale_ref loc,
    format_string<T...> fmt,
    T&&... args);

» more...

Formats arguments with the given text style, writes the result to the output iterator out and returns the iterator past the end of the output range.

template<
    typename OutputIt,
    typename... T>
OutputIt
format_to(
    OutputIt out,
    text_style ts,
    format_string<T...> fmt,
    T&&... args);

» more...

template<
    typename OutputIt,
    typename S,
    typename... T,
    typename Char = /* implementation-defined */,
    bool enable = detail::is_output_iterator<OutputIt, Char>::value && detail::is_exotic_char<Char>::value>
OutputIt
format_to(
    OutputIt out,
    locale_ref loc,
    S const& fmt,
    T&&... args)
requires enable;

» more...

Synopsis

Declared in <fmt/xchar.h>

template<
    typename OutputIt,
    typename... T>
OutputIt
format_to(
    OutputIt out,
    wformat_string<T...> fmt,
    T&&... args);

Synopsis

Declared in <fmt/base.h>

template<
    size_t N,
    typename... T>
format_to_result
format_to(
    char(& out)[N],
    format_string<T...> fmt,
    T&&... args);

Synopsis

Declared in <fmt/base.h>

template<
    typename OutputIt,
    typename... T>
remove_cvref_t<OutputIt>
format_to(
    OutputIt&& out,
    format_string<T...> fmt,
    T&&... args);

Description

Example:

auto out = std::vector<char>(); fmt::format_to(std::back_inserter(out), "{}", 42);

Synopsis

Declared in <fmt/compile.h>

template<
    typename OutputIt,
    typename CompiledFormat,
    typename... T>
constexpr
OutputIt
format_to(
    OutputIt out,
    CompiledFormat const& cf,
    T const&... args);

Synopsis

Declared in <fmt/compile.h>

template<
    typename OutputIt,
    typename S,
    typename... T>
constexpr
OutputIt
format_to(
    OutputIt out,
    S const&,
    T&&... args);

Synopsis

Declared in <fmt/xchar.h>

template<
    typename OutputIt,
    typename S,
    typename... T,
    typename Char = /* implementation-defined */>
OutputIt
format_to(
    OutputIt out,
    S const& fmt,
    T&&... args);

Synopsis

Declared in <fmt/format.h>

template<
    typename OutputIt,
    typename... T>
OutputIt
format_to(
    OutputIt out,
    locale_ref loc,
    format_string<T...> fmt,
    T&&... args);

Synopsis

Declared in <fmt/color.h>

template<
    typename OutputIt,
    typename... T>
OutputIt
format_to(
    OutputIt out,
    text_style ts,
    format_string<T...> fmt,
    T&&... args);

Description

Example:

std::vector<char> out; fmt::format_to(std::back_inserter(out), fmt::emphasis::bold | fg(fmt::color::red), "{}", 42);

Parameters

Name	Description
ts	A text style consisting of foreground and background colors and emphasis.

Synopsis

Declared in <fmt/xchar.h>

template<
    typename OutputIt,
    typename S,
    typename... T,
    typename Char = /* implementation-defined */,
    bool enable = detail::is_output_iterator<OutputIt, Char>::value && detail::is_exotic_char<Char>::value>
OutputIt
format_to(
    OutputIt out,
    locale_ref loc,
    S const& fmt,
    T&&... args)
requires enable;

Synopses

Declared in <fmt/base.h>

Formats args according to specifications in fmt, writes up to n characters of the result to the output iterator out and returns the total (not truncated) output size and the iterator past the end of the output range. format_to_n does not append a terminating null character.

template<
    typename OutputIt,
    typename... T>
format_to_n_result<OutputIt>
format_to_n(
    OutputIt out,
    size_t n,
    format_string<T...> fmt,
    T&&... args);

» more...

template<
    typename OutputIt,
    typename... T>
format_to_n_result<OutputIt>
format_to_n(
    OutputIt out,
    size_t n,
    wformat_string<T...> fmt,
    T&&... args);

» more...

template<
    typename OutputIt,
    typename S,
    typename... T>
format_to_n_result<OutputIt>
format_to_n(
    OutputIt out,
    size_t n,
    S const& fmt,
    T&&... args);

» more...

template<
    typename OutputIt,
    typename S,
    typename... T,
    typename Char = /* implementation-defined */>
format_to_n_result<OutputIt>
format_to_n(
    OutputIt out,
    size_t n,
    S const& fmt,
    T&&... args);

» more...

Synopsis

Declared in <fmt/base.h>

template<
    typename OutputIt,
    typename... T>
format_to_n_result<OutputIt>
format_to_n(
    OutputIt out,
    size_t n,
    format_string<T...> fmt,
    T&&... args);

Synopsis

Declared in <fmt/xchar.h>

template<
    typename OutputIt,
    typename... T>
format_to_n_result<OutputIt>
format_to_n(
    OutputIt out,
    size_t n,
    wformat_string<T...> fmt,
    T&&... args);

Synopsis

Declared in <fmt/compile.h>

template<
    typename OutputIt,
    typename S,
    typename... T>
format_to_n_result<OutputIt>
format_to_n(
    OutputIt out,
    size_t n,
    S const& fmt,
    T&&... args);

Synopsis

Declared in <fmt/xchar.h>

template<
    typename OutputIt,
    typename S,
    typename... T,
    typename Char = /* implementation-defined */>
format_to_n_result<OutputIt>
format_to_n(
    OutputIt out,
    size_t n,
    S const& fmt,
    T&&... args);

Synopses

Declared in <fmt/base.h>

Returns the number of chars in the output of format(fmt, args...).

template<typename... T>
[[nodiscard]]
size_t
formatted_size(
    format_string<T...> fmt,
    T&&... args);

» more...

template<
    typename S,
    typename... T>
constexpr
size_t
formatted_size(
    S const& fmt,
    T&&... args);

» more...

template<
    typename S,
    typename... T,
    typename Char = /* implementation-defined */>
size_t
formatted_size(
    S const& fmt,
    T&&... args);

» more...

template<typename... T>
[[nodiscard]]
size_t
formatted_size(
    locale_ref loc,
    format_string<T...> fmt,
    T&&... args);

» more...

Synopsis

Declared in <fmt/base.h>

template<typename... T>
[[nodiscard]]
size_t
formatted_size(
    format_string<T...> fmt,
    T&&... args);

Return Value

the number of chars in the output of format(fmt, args...).

Synopsis

Declared in <fmt/compile.h>

template<
    typename S,
    typename... T>
constexpr
size_t
formatted_size(
    S const& fmt,
    T&&... args);

Synopsis

Declared in <fmt/xchar.h>

template<
    typename S,
    typename... T,
    typename Char = /* implementation-defined */>
size_t
formatted_size(
    S const& fmt,
    T&&... args);

Synopsis

Declared in <fmt/format.h>

template<typename... T>
[[nodiscard]]
size_t
formatted_size(
    locale_ref loc,
    format_string<T...> fmt,
    T&&... args);

Synopses

Declared in <fmt/printf.h>

Formats args according to specifications in fmt and writes the output to f.

template<typename... T>
int
fprintf(
    FILE* f,
    string_view fmt,
    T const&... args);

» more...

template<typename... T>
[[deprecated]]
int
fprintf(
    FILE* f,
    basic_string_view<wchar_t> fmt,
    T const&... args);

» more...

Synopsis

Declared in <fmt/printf.h>

template<typename... T>
int
fprintf(
    FILE* f,
    string_view fmt,
    T const&... args);

Description

Example:

fmt::fprintf(stderr, "Don't %s!", "panic");

Synopsis

Declared in <fmt/printf.h>

template<typename... T>
[[deprecated]]
int
fprintf(
    FILE* f,
    basic_string_view<wchar_t> fmt,
    T const&... args);

Synopses

Declared in <fmt/chrono.h>

Converts given time since epoch as std::time_t value into calendar time, expressed in Coordinated Universal Time (UTC). Unlike std::gmtime, this function is thread-safe on most platforms.

tm
gmtime(time_t time);

» more...

template<typename Duration>
tm
gmtime(sys_time<Duration> time_point);

» more...

Synopsis

Declared in <fmt/chrono.h>

tm
gmtime(time_t time);

Synopsis

Declared in <fmt/chrono.h>

template<typename Duration>
tm
gmtime(sys_time<Duration> time_point);

Synopsis

Declared in <fmt/format.h>

template<typename T>
group_digits_view<T>
group_digits(T value);

Description

Example:

fmt::print("{}", fmt::group_digits(12345)); // Output: "12,345"

Synopses

Declared in <fmt/ranges.h>

Returns an object that formats std::initializer_list with elements separated by sep.

template<typename T>
[[deprecated]]
join_view<T const*, T const*>
join(
    std::initializer_list<T> list,
    string_view sep);

» more...

template<typename T>
[[deprecated]]
join_view<T const*, T const*, wchar_t>
join(
    std::initializer_list<T> list,
    wstring_view sep);

» more...

Returns an object that formats std::tuple with elements separated by sep.

template<typename Tuple>
constexpr
tuple_join_view<Tuple, char>
join(
    Tuple const& tuple,
    string_view sep);

» more...

Returns a view that formats range with elements separated by sep.

template<typename Range>
constexpr
join_view<decltype(detail::range_begin(r)), decltype(detail::range_end(r))>
join(
    Range&& r,
    string_view sep);

» more...

template<
    typename Tuple,
    typename S,
    typename Char = ::value_type>
tuple_join_view<Tuple, Char>
join(
    Tuple const& tuple,
    S&& sep);

» more...

template<
    typename Range,
    typename S,
    typename Char = ::value_type>
join_view<decltype(std::begin(range)), decltype(std::end(range)), Char>
join(
    Range&& range,
    S&& sep);

» more...

Returns a view that formats the iterator range [begin, end)] with elements separated by sep.

template<
    typename It,
    typename Sentinel>
join_view<It, Sentinel>
join(
    It begin,
    Sentinel end,
    string_view sep);

» more...

template<
    typename It,
    typename Sentinel,
    typename S,
    typename Char = ::value_type>
join_view<It, Sentinel, Char>
join(
    It begin,
    Sentinel end,
    S&& sep);

» more...

Synopsis

Declared in <fmt/ranges.h>

template<typename T>
[[deprecated]]
join_view<T const*, T const*>
join(
    std::initializer_list<T> list,
    string_view sep);

Description

Example:

fmt::print("{}", fmt::join({1, 2, 3}, ", ")); // Output: "1, 2, 3"

Synopsis

Declared in <fmt/xchar.h>

template<typename T>
[[deprecated]]
join_view<T const*, T const*, wchar_t>
join(
    std::initializer_list<T> list,
    wstring_view sep);

Synopsis

Declared in <fmt/ranges.h>

template<typename Tuple>
constexpr
tuple_join_view<Tuple, char>
join(
    Tuple const& tuple,
    string_view sep);

Description

Example:

auto t = std::tuple<int, char>(1, 'a'); fmt::print("{}", fmt::join(t, ", ")); // Output: 1, a

Return Value

an object that formats std::tuple with elements separated by sep.

Synopsis

Declared in <fmt/ranges.h>

template<typename Range>
constexpr
join_view<decltype(detail::range_begin(r)), decltype(detail::range_end(r))>
join(
    Range&& r,
    string_view sep);

Description

Example:

auto v = std::vector<int>{1, 2, 3}; fmt::print("{}", fmt::join(v, ", ")); // Output: 1, 2, 3

fmt::join applies passed format specifiers to the range elements:

fmt::print("{:02}", fmt::join(v, ", ")); // Output: 01, 02, 03

Return Value

a view that formats range with elements separated by sep.

Synopsis

Declared in <fmt/xchar.h>

template<
    typename Tuple,
    typename S,
    typename Char = ::value_type>
tuple_join_view<Tuple, Char>
join(
    Tuple const& tuple,
    S&& sep);

Synopsis

Declared in <fmt/xchar.h>

template<
    typename Range,
    typename S,
    typename Char = ::value_type>
join_view<decltype(std::begin(range)), decltype(std::end(range)), Char>
join(
    Range&& range,
    S&& sep);

Synopsis

Declared in <fmt/ranges.h>

template<
    typename It,
    typename Sentinel>
join_view<It, Sentinel>
join(
    It begin,
    Sentinel end,
    string_view sep);

Synopsis

Declared in <fmt/xchar.h>

template<
    typename It,
    typename Sentinel,
    typename S,
    typename Char = ::value_type>
join_view<It, Sentinel, Char>
join(
    It begin,
    Sentinel end,
    S&& sep);

Synopsis

Declared in <fmt/base.h>

template<
    typename Context = context,
    typename... T,
    int NUM_ARGS = int(sizeof...(T)),
    int NUM_NAMED_ARGS = detail::count_named_args<T...>(),
    ullong DESC = detail::make_descriptor<Context, T...>()>
[[always_inline]]
constexpr
/* implementation-defined */
make_format_args(T&... args);

Synopsis

Declared in <fmt/printf.h>

template<
    typename Char = char,
    typename... T>
decltype(fmt::make_format_args<basic_printf_context<Char>>(args...))
make_printf_args(T&... args);

Synopsis

Declared in <fmt/xchar.h>

template<typename... T>
constexpr
decltype(fmt::make_format_args<wformat_context>(args...))
make_wformat_args(T&... args);

Synopsis

Declared in <fmt/base.h>

template<typename T>
constexpr
T
max_of(
    T a,
    T b);

Synopsis

Declared in <fmt/base.h>

template<typename T>
constexpr
T
min_of(
    T a,
    T b);

Synopses

Declared in <fmt/color.h>

Bitwise disjunction operator

constexpr
text_style
operator|(
    emphasis lhs,
    emphasis rhs) noexcept;

» more...

Bitwise disjunction operator

constexpr
text_style
operator|(
    text_style lhs,
    text_style rhs);

» more...

Synopsis

Declared in <fmt/color.h>

constexpr
text_style
operator|(
    emphasis lhs,
    emphasis rhs) noexcept;

Return Value

A text style consisting of foreground and background colors and emphasis.

Parameters

Name	Description
lhs	The left operand
rhs	The right operand

Synopsis

Declared in <fmt/color.h>

constexpr
text_style
operator|(
    text_style lhs,
    text_style rhs);

Return Value

A text style consisting of foreground and background colors and emphasis.

Parameters

Name	Description
lhs	The left operand
rhs	The right operand

Synopses

Declared in <fmt/base.h>

Formats args according to specifications in fmt and writes the output to stdout.

template<typename... T>
void
print(
    format_string<T...> fmt,
    T&&... args);

» more...

template<typename... T>
void
print(
    wformat_string<T...> fmt,
    T&&... args);

» more...

template<
    typename S,
    typename... T>
void
print(
    S const& fmt,
    T&&... args);

» more...

Formats a string and prints it to stdout using ANSI escape sequences to specify text formatting.

template<typename... T>
void
print(
    text_style ts,
    format_string<T...> fmt,
    T&&... args);

» more...

Prints formatted data to the stream os.

template<typename... T>
void
print(
    std::ostream& os,
    format_string<T...> fmt,
    T&&... args);

» more...

template<typename... T>
void
print(
    std::wostream& os,
    wformat_string<T...> fmt,
    T&&... args);

» more...

Formats args according to specifications in fmt and writes the output to the file f.

template<typename... T>
void
print(
    FILE* f,
    format_string<T...> fmt,
    T&&... args);

» more...

template<typename... T>
void
print(
    FILE* f,
    wformat_string<T...> fmt,
    T&&... args);

» more...

template<
    typename S,
    typename... T>
void
print(
    FILE* f,
    S const& fmt,
    T&&... args);

» more...

Formats a string and prints it to the specified file stream using ANSI escape sequences to specify text formatting.

template<typename... T>
void
print(
    FILE* f,
    text_style ts,
    format_string<T...> fmt,
    T&&... args);

» more...

Synopsis

Declared in <fmt/base.h>

template<typename... T>
void
print(
    format_string<T...> fmt,
    T&&... args);

Description

Example:

fmt::print("The answer is {}.", 42);

Synopsis

Declared in <fmt/xchar.h>

template<typename... T>
void
print(
    wformat_string<T...> fmt,
    T&&... args);

Synopsis

Declared in <fmt/compile.h>

template<
    typename S,
    typename... T>
void
print(
    S const& fmt,
    T&&... args);

Synopsis

Declared in <fmt/color.h>

template<typename... T>
void
print(
    text_style ts,
    format_string<T...> fmt,
    T&&... args);

Description

Example:

fmt::print(fmt::emphasis::bold | fg(fmt::color::red), "Elapsed time: {0:.2f} seconds", 1.23);

Parameters

Name	Description
ts	A text style consisting of foreground and background colors and emphasis.

Synopsis

Declared in <fmt/ostream.h>

template<typename... T>
void
print(
    std::ostream& os,
    format_string<T...> fmt,
    T&&... args);

Description

Example:

fmt::print(cerr, "Don't {}!", "panic");

Synopsis

Declared in <fmt/xchar.h>

template<typename... T>
void
print(
    std::wostream& os,
    wformat_string<T...> fmt,
    T&&... args);

Synopsis

Declared in <fmt/base.h>

template<typename... T>
void
print(
    FILE* f,
    format_string<T...> fmt,
    T&&... args);

Description

Example:

fmt::print(stderr, "Don't {}!", "panic");

Synopsis

Declared in <fmt/xchar.h>

template<typename... T>
void
print(
    FILE* f,
    wformat_string<T...> fmt,
    T&&... args);

Synopsis

Declared in <fmt/compile.h>

template<
    typename S,
    typename... T>
void
print(
    FILE* f,
    S const& fmt,
    T&&... args);

Synopsis

Declared in <fmt/color.h>

template<typename... T>
void
print(
    FILE* f,
    text_style ts,
    format_string<T...> fmt,
    T&&... args);

Description

Example:

fmt::print(fmt::emphasis::bold | fg(fmt::color::red), "Elapsed time: {0:.2f} seconds", 1.23);

Parameters

Name	Description
ts	A text style consisting of foreground and background colors and emphasis.

Synopsis

Declared in <fmt/printf.h>

template<typename... T>
int
printf(
    string_view fmt,
    T const&... args);

Description

Example:

fmt::printf("Elapsed time: %.2f seconds", 1.23);

Synopses

Declared in <fmt/base.h>

Formats args according to specifications in fmt and writes the output to stdout followed by a newline.

template<typename... T>
void
println(
    format_string<T...> fmt,
    T&&... args);

» more...

template<typename... T>
void
println(
    wformat_string<T...> fmt,
    T&&... args);

» more...

Formats a string and prints it to stdout followed by a newline, using ANSI escape sequences to specify text formatting.

template<typename... T>
void
println(
    text_style ts,
    format_string<T...> fmt,
    T&&... args);

» more...

template<typename... T>
void
println(
    std::ostream& os,
    format_string<T...> fmt,
    T&&... args);

» more...

template<typename... T>
void
println(
    std::wostream& os,
    wformat_string<T...> fmt,
    T&&... args);

» more...

Formats args according to specifications in fmt and writes the output to the file f followed by a newline.

template<typename... T>
void
println(
    FILE* f,
    format_string<T...> fmt,
    T&&... args);

» more...

template<typename... T>
void
println(
    FILE* f,
    wformat_string<T...> fmt,
    T&&... args);

» more...

Formats a string and prints it to the specified file stream followed by a newline, using ANSI escape sequences to specify text formatting.

template<typename... T>
void
println(
    FILE* f,
    text_style ts,
    format_string<T...> fmt,
    T&&... args);

» more...

Synopsis

Declared in <fmt/base.h>

template<typename... T>
void
println(
    format_string<T...> fmt,
    T&&... args);

Synopsis

Declared in <fmt/xchar.h>

template<typename... T>
void
println(
    wformat_string<T...> fmt,
    T&&... args);

Synopsis

Declared in <fmt/color.h>

template<typename... T>
void
println(
    text_style ts,
    format_string<T...> fmt,
    T&&... args);

Description

Example:

fmt::println(fmt::emphasis::bold | fg(fmt::color::red), "Elapsed time: {0:.2f} seconds", 1.23);

Parameters

Name	Description
ts	A text style consisting of foreground and background colors and emphasis.

Synopsis

Declared in <fmt/ostream.h>

template<typename... T>
void
println(
    std::ostream& os,
    format_string<T...> fmt,
    T&&... args);

Synopsis

Declared in <fmt/xchar.h>

template<typename... T>
void
println(
    std::wostream& os,
    wformat_string<T...> fmt,
    T&&... args);

Synopsis

Declared in <fmt/base.h>

template<typename... T>
void
println(
    FILE* f,
    format_string<T...> fmt,
    T&&... args);

Synopsis

Declared in <fmt/xchar.h>

template<typename... T>
void
println(
    FILE* f,
    wformat_string<T...> fmt,
    T&&... args);

Synopsis

Declared in <fmt/color.h>

template<typename... T>
void
println(
    FILE* f,
    text_style ts,
    format_string<T...> fmt,
    T&&... args);

Description

Example:

fmt::println(fmt::emphasis::bold | fg(fmt::color::red), "Elapsed time: {0:.2f} seconds", 1.23);

Parameters

Name	Description
ts	A text style consisting of foreground and background colors and emphasis.

Synopses

Declared in <fmt/format.h>

Converts p to const void* for pointer formatting.

template<typename T>
void const*
ptr(T p);

» more...

template<typename T>
void const*
ptr(std::shared_ptr<T> const& p);

» more...

template<
    typename T,
    typename Deleter>
void const*
ptr(std::unique_ptr<T, Deleter> const& p);

» more...

Synopsis

Declared in <fmt/format.h>

template<typename T>
void const*
ptr(T p);

Description

Example:

auto s = fmt::format("{}", fmt::ptr(p));

Synopsis

Declared in <fmt/std.h>

template<typename T>
void const*
ptr(std::shared_ptr<T> const& p);

Synopsis

Declared in <fmt/std.h>

template<
    typename T,
    typename Deleter>
void const*
ptr(std::unique_ptr<T, Deleter> const& p);

Synopsis

Declared in <fmt/base.h>

[[noreturn]]
void
report_error(char const* message);

Synopsis

Declared in <fmt/format.h>

void
report_system_error(
    int error_code,
    char const* message) noexcept;

Synopses

Declared in <fmt/base.h>

Creates a runtime format string.

runtime_format_string<>
runtime(string_view s);

» more...

runtime_format_string<wchar_t>
runtime(wstring_view s);

» more...

Synopsis

Declared in <fmt/base.h>

runtime_format_string<>
runtime(string_view s);

Description

Example:

// Check format string at runtime instead of compile-time. fmt::print(fmt::runtime("{:d}"), "I am not a number");

Synopsis

Declared in <fmt/xchar.h>

runtime_format_string<wchar_t>
runtime(wstring_view s);

Synopses

Declared in <fmt/printf.h>

Formats args according to specifications in fmt and returns the result as string.

template<typename... T>
std::string
sprintf(
    string_view fmt,
    T const&... args);

» more...

template<typename... T>
[[deprecated]]
std::wstring
sprintf(
    basic_string_view<wchar_t> fmt,
    T const&... args);

» more...

Synopsis

Declared in <fmt/printf.h>

template<typename... T>
std::string
sprintf(
    string_view fmt,
    T const&... args);

Description

Example:

std::string message = fmt::sprintf("The answer is %d", 42);

Synopsis

Declared in <fmt/printf.h>

template<typename... T>
[[deprecated]]
std::wstring
sprintf(
    basic_string_view<wchar_t> fmt,
    T const&... args);

Synopsis

Declared in <fmt/ostream.h>

template<typename T>
constexpr
/* implementation-defined */
streamed(T const& value);

Description

Example:

fmt::print("Current thread id: {}n", fmt::streamed(std::this_thread::get_id()));

Return Value

a view that formats value via an ostream operator<<.

Synopsis

Declared in <fmt/color.h>

template<typename T>
constexpr
/* implementation-defined */
styled(
    T const& value,
    text_style ts);

Description

Example:

fmt::print("Elapsed time: {0:.2f} seconds", fmt::styled(1.23, fmt::fg(fmt::color::green) | fmt::bg(fmt::color::blue)));

Parameters

Name	Description
ts	A text style consisting of foreground and background colors and emphasis.

Synopsis

Declared in <fmt/os.h>

std::error_category const&
system_category() noexcept;

Synopsis

Declared in <fmt/format.h>

template<typename... T>
std::system_error
system_error(
    int error_code,
    format_string<T...> fmt,
    T&&... args);

Description

Example:

// This throws std::system_error with the description // cannot open file 'madeup': No such file or directory // or similar (system message may vary). const char* filename = "madeup"; FILE* file = fopen(filename, "r"); if (!file) throw fmt::system_error(errno, "cannot open file '{}'", filename);

Return Value

An exception type that includes an error_code value.

Synopses

Declared in <fmt/format.h>

Converts value to std::string using the default format for type T.

template<typename T>
[[nodiscard]]
constexpr
std::string
to_string(T value);

» more...

template<typename T>
[[nodiscard]]
constexpr
std::string
to_string(T const& value);

» more...

template<typename T>
[[nodiscard]]
constexpr
std::string
to_string(T const& value);

» more...

template<size_t SIZE>
[[nodiscard]]
std::string
to_string(basic_memory_buffer<char, SIZE> const& buf);

» more...

Synopsis

Declared in <fmt/format.h>

template<typename T>
[[nodiscard]]
constexpr
std::string
to_string(T value);

Description

Example:

std::string answer = fmt::to_string(42);

Synopsis

Declared in <fmt/format.h>

template<typename T>
[[nodiscard]]
constexpr
std::string
to_string(T const& value);

Synopsis

Declared in <fmt/format.h>

template<typename T>
[[nodiscard]]
constexpr
std::string
to_string(T const& value);

Synopsis

Declared in <fmt/format.h>

template<size_t SIZE>
[[nodiscard]]
std::string
to_string(basic_memory_buffer<char, SIZE> const& buf);

Synopsis

Declared in <fmt/xchar.h>

template<typename T>
std::wstring
to_wstring(T const& value);

Synopsis

Declared in <fmt/format.h>

template<typename Enum>
constexpr
underlying_t<Enum>
underlying(Enum e) noexcept;

Description

Example:

enum class color { red, green, blue }; auto s = fmt::format("{}", fmt::underlying(color::red)); // s == "0"

Synopses

Declared in <fmt/format.h>

std::string
vformat(
    string_view fmt,
    format_args args);

» more...

template<typename Char>
std::basic_string<Char>
vformat(
    basic_string_view<Char> fmt,
    basic_format_args<buffered_context<Char>> args);

» more...

std::string
vformat(
    locale_ref loc,
    string_view fmt,
    format_args args);

» more...

std::string
vformat(
    text_style ts,
    string_view fmt,
    format_args args);

» more...

std::wstring
vformat(
    text_style ts,
    wstring_view fmt,
    wformat_args args);

» more...

template<
    typename S,
    typename Char = /* implementation-defined */>
std::basic_string<Char>
vformat(
    locale_ref loc,
    S const& fmt,
    basic_format_args<buffered_context<Char>> args);

» more...

Synopsis

Declared in <fmt/format.h>

std::string
vformat(
    string_view fmt,
    format_args args);

Synopsis

Declared in <fmt/xchar.h>

template<typename Char>
std::basic_string<Char>
vformat(
    basic_string_view<Char> fmt,
    basic_format_args<buffered_context<Char>> args);

Synopsis

Declared in <fmt/format.h>

std::string
vformat(
    locale_ref loc,
    string_view fmt,
    format_args args);

Synopsis

Declared in <fmt/color.h>

std::string
vformat(
    text_style ts,
    string_view fmt,
    format_args args);

Synopsis

Declared in <fmt/xchar.h>

std::wstring
vformat(
    text_style ts,
    wstring_view fmt,
    wformat_args args);

Synopsis

Declared in <fmt/xchar.h>

template<
    typename S,
    typename Char = /* implementation-defined */>
std::basic_string<Char>
vformat(
    locale_ref loc,
    S const& fmt,
    basic_format_args<buffered_context<Char>> args);

Synopses

Declared in <fmt/base.h>

template<size_t N>
[[deprecated]]
format_to_result
vformat_to(
    char(& out)[N],
    string_view fmt,
    format_args args);

» more...

Formats a string and writes the output to out.

template<typename OutputIt>
remove_cvref_t<OutputIt>
vformat_to(
    OutputIt&& out,
    string_view fmt,
    format_args args);

» more...

template<
    typename OutputIt,
    typename S,
    typename Char = /* implementation-defined */>
OutputIt
vformat_to(
    OutputIt out,
    S const& fmt,
    basic_format_args<buffered_context<Char>> args);

» more...

template<typename OutputIt>
OutputIt
vformat_to(
    OutputIt out,
    locale_ref loc,
    string_view fmt,
    format_args args);

» more...

Formats a string with the given text_style and writes the output to out.

template<typename OutputIt>
OutputIt
vformat_to(
    OutputIt out,
    text_style ts,
    string_view fmt,
    format_args args);

» more...

template<
    typename S,
    typename OutputIt,
    typename... Args,
    typename Char = /* implementation-defined */>
OutputIt
vformat_to(
    OutputIt out,
    locale_ref loc,
    S const& fmt,
    basic_format_args<buffered_context<Char>> args);

» more...

Synopsis

Declared in <fmt/base.h>

template<size_t N>
[[deprecated]]
format_to_result
vformat_to(
    char(& out)[N],
    string_view fmt,
    format_args args);

Synopsis

Declared in <fmt/base.h>

template<typename OutputIt>
remove_cvref_t<OutputIt>
vformat_to(
    OutputIt&& out,
    string_view fmt,
    format_args args);

Synopsis

Declared in <fmt/xchar.h>

template<
    typename OutputIt,
    typename S,
    typename Char = /* implementation-defined */>
OutputIt
vformat_to(
    OutputIt out,
    S const& fmt,
    basic_format_args<buffered_context<Char>> args);

Synopsis

Declared in <fmt/format.h>

template<typename OutputIt>
OutputIt
vformat_to(
    OutputIt out,
    locale_ref loc,
    string_view fmt,
    format_args args);

Synopsis

Declared in <fmt/color.h>

template<typename OutputIt>
OutputIt
vformat_to(
    OutputIt out,
    text_style ts,
    string_view fmt,
    format_args args);

Parameters

Name	Description
ts	A text style consisting of foreground and background colors and emphasis.

Synopsis

Declared in <fmt/xchar.h>

template<
    typename S,
    typename OutputIt,
    typename... Args,
    typename Char = /* implementation-defined */>
OutputIt
vformat_to(
    OutputIt out,
    locale_ref loc,
    S const& fmt,
    basic_format_args<buffered_context<Char>> args);

Synopses

Declared in <fmt/base.h>

template<
    typename OutputIt,
    typename... T>
format_to_n_result<OutputIt>
vformat_to_n(
    OutputIt out,
    size_t n,
    string_view fmt,
    format_args args);

» more...

template<
    typename OutputIt,
    typename Char,
    typename... Args>
format_to_n_result<OutputIt>
vformat_to_n(
    OutputIt out,
    size_t n,
    basic_string_view<Char> fmt,
    basic_format_args<buffered_context<Char>> args);

» more...

Synopsis

Declared in <fmt/base.h>

template<
    typename OutputIt,
    typename... T>
format_to_n_result<OutputIt>
vformat_to_n(
    OutputIt out,
    size_t n,
    string_view fmt,
    format_args args);

Synopsis

Declared in <fmt/xchar.h>

template<
    typename OutputIt,
    typename Char,
    typename... Args>
format_to_n_result<OutputIt>
vformat_to_n(
    OutputIt out,
    size_t n,
    basic_string_view<Char> fmt,
    basic_format_args<buffered_context<Char>> args);

Synopsis

Declared in <fmt/printf.h>

template<typename Char>
int
vfprintf(
    FILE* f,
    basic_string_view<Char> fmt,
    vprintf_args<Char>::type args);

Synopses

Declared in <fmt/base.h>

void
vprint(
    string_view fmt,
    format_args args);

» more...

void
vprint(
    wstring_view fmt,
    wformat_args args);

» more...

void
vprint(
    std::ostream& os,
    string_view fmt,
    format_args args);

» more...

void
vprint(
    std::wostream& os,
    wstring_view fmt,
    wformat_args args);

» more...

void
vprint(
    FILE* f,
    string_view fmt,
    format_args args);

» more...

void
vprint(
    FILE* f,
    wstring_view fmt,
    wformat_args args);

» more...

void
vprint(
    FILE* f,
    text_style ts,
    string_view fmt,
    format_args args);

» more...

Synopsis

Declared in <fmt/base.h>

void
vprint(
    string_view fmt,
    format_args args);

Synopsis

Declared in <fmt/xchar.h>

void
vprint(
    wstring_view fmt,
    wformat_args args);

Synopsis

Declared in <fmt/ostream.h>

void
vprint(
    std::ostream& os,
    string_view fmt,
    format_args args);

Synopsis

Declared in <fmt/xchar.h>

void
vprint(
    std::wostream& os,
    wstring_view fmt,
    wformat_args args);

Synopsis

Declared in <fmt/base.h>

void
vprint(
    FILE* f,
    string_view fmt,
    format_args args);

Synopsis

Declared in <fmt/xchar.h>

void
vprint(
    FILE* f,
    wstring_view fmt,
    wformat_args args);

Synopsis

Declared in <fmt/color.h>

void
vprint(
    FILE* f,
    text_style ts,
    string_view fmt,
    format_args args);

Synopsis

Declared in <fmt/base.h>

void
vprint_buffered(
    FILE* f,
    string_view fmt,
    format_args args);

Synopses

Declared in <fmt/base.h>

void
vprintln(
    FILE* f,
    string_view fmt,
    format_args args);

» more...

void
vprintln(
    FILE* f,
    text_style ts,
    string_view fmt,
    format_args args);

» more...

Synopsis

Declared in <fmt/base.h>

void
vprintln(
    FILE* f,
    string_view fmt,
    format_args args);

Synopsis

Declared in <fmt/color.h>

void
vprintln(
    FILE* f,
    text_style ts,
    string_view fmt,
    format_args args);

Synopsis

Declared in <fmt/printf.h>

template<typename Char>
std::basic_string<Char>
vsprintf(
    basic_string_view<Char> fmt,
    vprintf_args<Char>::type args);

Synopsis

Declared in <fmt/format.h>

std::system_error
vsystem_error(
    int error_code,
    string_view fmt,
    format_args args);

Synopsis

Declared in <fmt/base.h>

constexpr
bool
operator==(
    basic_string_view lhs,
    basic_string_view rhs);

Return Value

true if the objects are equal, false otherwise

Parameters

Name	Description
lhs	The left operand
rhs	The right operand

Synopsis

Declared in <fmt/base.h>

bool
operator!=(
    basic_string_view lhs,
    basic_string_view rhs);

Return Value

true if the objects are not equal, false otherwise

Parameters

Name	Description
lhs	The left operand
rhs	The right operand

Synopsis

Declared in <fmt/base.h>

bool
operator<(
    basic_string_view lhs,
    basic_string_view rhs);

Return Value

true if the left object is less than the right object, false otherwise

Parameters

Name	Description
lhs	The left operand
rhs	The right operand

Synopsis

Declared in <fmt/base.h>

bool
operator<=(
    basic_string_view lhs,
    basic_string_view rhs);

Return Value

true if the left object is less than or equal to the right object, false otherwise

Parameters

Name	Description
lhs	The left operand
rhs	The right operand

Synopsis

Declared in <fmt/base.h>

bool
operator>(
    basic_string_view lhs,
    basic_string_view rhs);

Return Value

true if the left object is greater than the right object, false otherwise

Parameters

Name	Description
lhs	The left operand
rhs	The right operand

Synopsis

Declared in <fmt/base.h>

bool
operator>=(
    basic_string_view lhs,
    basic_string_view rhs);

Return Value

true if the left object is greater than or equal to the right object, false otherwise

Parameters

Name	Description
lhs	The left operand
rhs	The right operand

Synopsis

Declared in <fmt/base.h>

template<
    typename T,
    typename Char = char>
concept formattable = is_formattable<remove_reference_t<T>, Char>::value;

Global namespace

Namespaces

fmt namespace

Namespaces

Types

Type Aliases

Enums

Functions

Concepts

fmt::enums namespace

Functions

fmt::safe_duration_cast namespace

Functions

Namespaces

Types

Type Aliases

Enums

Functions

Concepts

Functions

Synopsis

Functions

Synopses

Synopsis

Synopsis

Synopsis

Synopsis

Synopses

Synopsis

Description

Synopsis

Synopsis

Synopsis

Synopsis

Synopsis

Synopsis

Synopsis

Synopsis

Synopsis

Synopsis

Synopsis

Synopsis

Synopsis

Synopsis

Synopsis

Synopsis

Synopsis

Synopsis

Synopsis

Synopsis

Synopsis

Synopsis

Synopsis

Synopsis

Synopsis

Synopsis

Synopsis

Synopsis

Synopsis

Synopsis

Synopsis

Synopsis

Synopsis

Synopsis

Synopsis

Synopsis

Synopsis

Synopsis

Synopsis

Synopsis

Synopsis

Synopsis

Synopsis

Synopsis

Synopsis

Synopsis

Synopsis

Synopsis

Synopsis

Type Aliases