Ch11.3.1: Manipulators Reference

This page is a complete reference of every manipulator provided by fast_io. Manipulators live in the namespace ::fast_io::manipulators, which is aliased as ::fast_io::mnp for convenience. They are passed directly to print, println, or scan to control how values are formatted or parsed — no format strings, no implicit conversions, no surprises.

Each section below groups the manipulators by purpose. The tables list the manipulator signature, a short description, and a small usage example using the ::fast_io::mnp:: prefix.

1. Integer Base Manipulators

Control the numeric base used when printing or scanning integers. The base<N> family accepts any base from 2 to 36. Shorthand manipulators are provided for the most common bases: decimal (10), octal (8), binary (2), and hexadecimal (16). The upper variants emit uppercase digits A–F instead of a–f.

2. Pointer / Address Manipulators

Format pointers, addresses, and callable references in a platform-appropriate hexadecimal representation. Each manipulator targets a specific kind of address so the output is unambiguous.

3. Boolean Manipulators

Control how bool values are printed. By default, booleans print as 1 or 0. The boolalpha manipulators switch to textual representation.

4. Floating-Point Manipulators

Choose the notation used when printing floating-point values. An optional second argument n controls the precision (number of digits after the radix point). The comma_ variants insert locale-style thousand separators into the integer part of the output.

5. Width / Alignment Manipulators

Pad the output of t to a minimum field width of n columns. An optional third argument ch sets the fill character (default is a space). These mirror the alignment options familiar from <iomanip> but are resolved entirely at compile time where possible.

6. Conditional Manipulators

Select between two alternative outputs at runtime based on a boolean predicate. When the predicate is true, t1 is printed; otherwise t2 is printed. The single-argument overload omits the else branch (printing nothing when the predicate is false).

7. Percentage Manipulators

Format the ratio num / deno as a human-readable percentage. percentage_conventional multiplies by 100 and appends %. The base_percentage_conventional<N> variant lets you specify the output base N (default 10) for the percentage digits.

8. Ordinal Manipulator

Append the English ordinal suffix (st, nd, rd, or th) to an integer.

9. Range View Manipulator

Print every element of a range, separated by a given delimiter. This replaces the need for manual loops when displaying containers such as std::vector, std::array, or any std::ranges::range.

10. Character / String Manipulators

Low-level helpers for printing individual characters and C-style string pointers without relying on null-termination assumptions.

11. Hex Encoding Manipulators

Encode a contiguous sequence of bytes as a hexadecimal string. These manipulators accept either a pair of iterators [first, last) or an entire contiguous range (such as std::vector<std::byte>).

12. Crypto Hash File Manipulators

Adapt a crypto-hash context (e.g. sha256_context, md5_context) so it can be written to as if it were an output stream. The as_file family wraps the context reference and selects the character type of the output stream. Once the hashing is done, use the hex-encoding manipulators above or hash_digest to retrieve the result.

A complete hashing example:

#include <fast_io.h>
#include <fast_io_crypto_hash.h>

using namespace fast_io::io;

int main()
{
    ::fast_io::sha256_context ctx;
    print(::fast_io::mnp::as_file(ctx), "Hello, fast_io!\n");
    ctx.do_final();
    println(::fast_io::mnp::hash_digest(ctx));
}

Summary

Every manipulator in ::fast_io::mnp:: is a lightweight, trivially-copyable wrapper that carries formatting intent through the type system. There are no global formatting flags, no locale-dependent surprises, and no format strings to get wrong. Combined with print / println / scan, they give you full control over input and output formatting — safely and efficiently.