diff --git a/dev/fmt.css b/dev/fmt.css index d9d34b3c..3ad561d6 100644 --- a/dev/fmt.css +++ b/dev/fmt.css @@ -9,3 +9,33 @@ .docblock-desc { margin-left: 1em; } + +.features-container { + display: flex; + flex-wrap: wrap; + gap: 20px; + justify-content: center; /* Center the items horizontally */ +} + +.feature { + flex: 1 1 calc(50% - 20px); /* Two columns with space between */ + max-width: 600px; /* Set the maximum width for the feature boxes */ + box-sizing: border-box; + padding: 10px; + overflow: hidden; /* Hide overflow content */ + text-overflow: ellipsis; /* Handle text overflow */ + white-space: normal; /* Allow text wrapping */ +} + +.feature h2 { + margin-top: 0px; + font-weight: bold; +} + +@media (max-width: 768px) { + .feature { + flex: 1 1 100%; /* Stack columns on smaller screens */ + max-width: 100%; /* Allow full width on smaller screens */ + white-space: normal; /* Allow text wrapping on smaller screens */ + } +} diff --git a/dev/index.html b/dev/index.html index aef9abd3..8b111a9d 100644 --- a/dev/index.html +++ b/dev/index.html @@ -66,7 +66,7 @@
{fmt} is an open-source formatting library providing a fast and safe -alternative to C stdio and C++ iostreams.
-What users say:
---Thanks for creating this library. It’s been a hole in C++ for a long time. -I’ve used both
-boost::format
andloki::SPrintf
, and neither felt like the -right answer. This does.
The format API is similar in spirit to the C printf
family of function
-but is safer, simpler and several times
-faster
-than common standard library implementations.
-The format string syntax is similar to the one used by
-str.format
-in Python:
std::string s = fmt::format("The answer is {}.", 42);
-
-The fmt::format
function returns a string \"The answer is 42.\". You
-can use fmt::memory_buffer
to avoid constructing std::string
:
auto out = fmt::memory_buffer();
-fmt::format_to(std::back_inserter(out),
- "For a moment, {} happened.", "nothing");
-auto data = out.data(); // pointer to the formatted data
-auto size = out.size(); // size of the formatted data
-
-The fmt::print
function performs formatting and writes the result to a
-stream:
fmt::print(stderr, "System error code = {}\n", errno);
-
-If you omit the file argument the function will print to stdout
:
fmt::print("Don't {}\n", "panic");
-
-The format API also supports positional arguments useful for -localization:
-fmt::print("I'd rather be {1} than {0}.", "right", "happy");
-
-You can pass named arguments with fmt::arg
:
fmt::print("Hello, {name}! The answer is {number}. Goodbye, {name}.",
- fmt::arg("name", "World"), fmt::arg("number", 42));
-
-If your compiler supports C++11 user-defined literals, the suffix _a
-offers an alternative, slightly terser syntax for named arguments:
using namespace fmt::literals;
-fmt::print("Hello, {name}! The answer is {number}. Goodbye, {name}.",
- "name"_a="World", "number"_a=42);
-
-The library is fully type safe, automatic memory management prevents -buffer overflow, errors in format strings are reported using exceptions -or at compile time. For example, the code
-fmt::format("The answer is {:d}", "forty-two");
-
-throws the format_error
exception because the argument "forty-two"
-is a string while the format code d
only applies to integers.
The code
-format(FMT_STRING("The answer is {:d}"), "forty-two");
-
-reports a compile-time error on compilers that support relaxed constexpr
.
-See Compile-Time Format String Checks
-for details.
The following code
-fmt::format("Cyrillic letter {}", L'\x42e');
-
-produces a compile-time error because wide character L'\x42e'
cannot
-be formatted into a narrow string. For comparison, writing a wide
-character to std::ostream
results in its numeric value being written
-to the stream (i.e. 1070 instead of letter 'ю' which is represented by
-L'\x42e'
if we use Unicode) which is rarely desirable.
The library produces compact per-call compiled code. For example -(godbolt),
-#include <fmt/core.h>
-
-int main() {
- fmt::print("The answer is {}.", 42);
-}
-
-compiles to just
-main: # @main
- sub rsp, 24
- mov qword ptr [rsp], 42
- mov rcx, rsp
- mov edi, offset .L.str
- mov esi, 17
- mov edx, 1
- call fmt::v7::vprint(fmt::v7::basic_string_view<char>, fmt::v7::format_args)
- xor eax, eax
- add rsp, 24
- ret
-.L.str:
- .asciz "The answer is {}."
-
-The library is highly portable and relies only on a small set of C++11 -features:
-These are available in GCC 4.8, Clang 3.4, MSVC 19.0 (2015) and more -recent compiler version. For older compilers use {fmt} version -4.x which is -maintained and only requires C++98.
-The output of all formatting functions is consistent across platforms. -For example,
-fmt::print("{}", std::numeric_limits<double>::infinity());
-
-always prints inf
while the output of printf
is platform-dependent.
{fmt} has a small self-contained code base with the core library -consisting of just three header files and no external dependencies. A -permissive MIT license allows -using the library both in open-source and commercial projects.
- +
+ Inspired by the Python's formatting facility, {fmt} provides a safe
+ replacement for the printf
family of functions. Errors in format
+ strings, which are a common source of vulnerabilities in C, are reported
+ at compile time. For example:
+
+
fmt::format("The answer is {:d}", "forty-two");
+
+ will give a compile-time error because d
is not a valid
+ format specifier for strings. APIs like
+ fmt::format
prevent buffer overflow errors via
+ automatic memory management.
+
+→ Learn more
++ Formatting of most standard types including all containers, dates and + times is supported out-of-the-box. + For example: + +
fmt::print("{}", std::vector{1, 2, 3});
+
+ prints the vector in a JSON-like format:
+
+ [1, 2, 3]
+
+ You can make your own types formattable and even make compile-time
+ checks work for them.
+
+→ Learn more
+
+ {fmt} can be anywhere from tens of percent to 20-30 times faster than
+ iostreams and sprintf
, especially on numeric formatting.
+
+
+
+The library minimizes dynamic memory allocations and allows
+format string compilation.
+
+ {fmt} provides portable Unicode support on major operating systems
+ with UTF-8 and normal char
strings. For example:
+
+
fmt::print("Слава Україні!");
+
+ will be printed correctly on Linux, macOS and even Windows console regardless
+ of the codepages.
+
++ The default is locale-independent but you can opt into localized + formatting and {fmt} makes it work with Unicode, working around problems in + the standard libary. +
+
+ The library makes extensive use of type erasure to achieve fast
+ compilation. fmt/base.h
provides a subset
+ of the API with minimal include dependencies and enough functionality
+ to replace all uses of *printf
.
+
+ Code using {fmt} is usually several times faster to compile than the
+ equivalent iostreams code and while printf
is faster still, the
+ gap is narrowing.
+
+ Type erasure is also used to prevent template bloat resulting in compact
+ per-call binary code. For example, a call to fmt::print
with
+ a single argument is less than ten
+ x86-64 instructions, comparable to printf
despite adding
+ runtime safety and much smaller than the equivalent iostreams code.
+
+ The library itself has small binary footprint and some components such as + floating-point formatting can be disabled to make it even smaller for + resource constrained devices. +
++{fmt} has a small self-contained codebase with the core consisting of +just three header files and no external dependencies. +
++The library is highly portable and requires only on a minimal subset of +C++11 features which are available in GCC 4.8, Clang 3.4, MSVC 19.0 (2015) +and later. Newer compiler and standard library features are used if available +and enable additional functionality. +
++Where possible, the output of formatting functions is consistent across +platforms. +
+ ++ {fmt} is in top hundred open-source libraries on GitHub and has hundreds of + all-time contributors. +
++ Permissive MIT license + allows using the library both in open-source and commercial projects. +
+{{
and }}
.
The grammar for a replacement field is as follows:
-
-replacement_field ::= "{" [arg_id] [":" (replacement_field ::= "{" [arg_id] [":" (format_spec | chrono_format_spec)] "}"
arg_id ::= integer | identifier
integer ::= digit+
@@ -493,8 +493,8 @@ Format Specification Mini-Language
supported by the numeric types.
The general form of a standard format specifier is:
-
-format_spec ::= [[fill]align][sign]["#"]["0"][width]["." precision]["L"][type]
+format_spec ::= [[fill]align][sign]["#"]["0"][width]["." precision]["L"][type]
fill ::= <a character other than '{' or '}'>
align ::= "<" | ">" | "^"
sign ::= "+" | "-" | " "
@@ -802,12 +802,12 @@ Chrono Format Specifications
Format specifications for chrono duration and time point types as well as
std::tm
have the following syntax:
-
-chrono_format_spec ::= [[fill]chrono_format_spec ::= [[fill]align][width]["." precision][chrono_specs]
-chrono_specs ::= conversion_spec | chrono_specs (conversion_spec | literal_char)
+chrono_specs ::= conversion_spec |
+ chrono_specs (conversion_spec | literal_char)
conversion_spec ::= "%" [padding_modifier] [locale_modifier] chrono_type
literal_char ::= <a character other than '{', '}' or '%'>
padding_modifier ::= "-" | "_" | "0"
@@ -1129,8 +1129,8 @@ Chrono Format Specifications
'V'
and 'W'
presentation types.
Range Format Specifications
Format specifications for range types have the following syntax:
-
-range_format_spec ::= ["n"][range_type][range_underlying_spec]
+range_format_spec ::= ["n"][range_type][range_underlying_spec]
The 'n'
option formats the range without the opening and closing brackets.