snprintf() [2/2]

template<typename... Args>

int fl::snprintf	(	char *	buffer,
		fl::size	size,
		const char *	format,
		const Args &...	args )

Snprintf-like formatting function that writes to a buffer.

Parameters

buffer	Output buffer to write formatted string to
size	Maximum number of characters to write (including null terminator)
format	Format string with placeholders like "%d", "%s", "%f" etc.
args	Arguments to format

Returns

Number of characters that would have been written if buffer was large enough

Supported format specifiers:

• d, i: integers (all integral types)
• u: unsigned integers
• o: octal integers
• f: floating point numbers
• s: strings (const char*, fl::string)
• c: characters
• x: hexadecimal (lowercase)
• X: hexadecimal (uppercase)
• p: pointers (formatted as 0x... hex)
• %%: literal % character

Generic placeholder:

• {}: formats the next argument by picking the natural specifier for its C++ type, so callers do not have to choose between d / u / ld / s / p or call .c_str(). Supported argument types are the same set the % specifiers support: all integral types (d), bool (as "true"/"false"), char (as a character, c), float/double (f), const char* and fl::string / fl::string_view (s), pointers (p), and unscoped enums (as their underlying integer). Scoped enums (enum class) do not compile through {} or d; cast at the call site. Passing any other type to {} is a compile error - {} deliberately does not fall back to a generic streaming path, to keep code size flat.
• {{: literal { character
• }}: literal } character
• A lone { or } that is not part of the above passes through literally.
• A {} with no remaining argument emits <missing_arg>, matching the behavior of a % specifier with no remaining argument.

Example usage:

char buffer[100];
int len = fl::snprintf(buffer, sizeof(buffer), "Value: %d, Name: %s", 42, "test");

Definition at line 1009 of file stdio.h.

                                                                                              {
    // Handle null buffer or zero size
    if (!buffer || size == 0) {
        return 0;
    }
    
    // Format to internal string stream
    sstream stream;
    printf_detail::format_impl(stream, format, args...);
    fl::string result = stream.str();
    
    // Get the formatted string length
    fl::size formatted_len = result.size();
    
    // Copy to buffer, ensuring null termination
    fl::size copy_len = (formatted_len < size - 1) ? formatted_len : size - 1;
    
    // Copy characters
    for (fl::size i = 0; i < copy_len; ++i) {
        buffer[i] = result[i];
    }
    
    // Null terminate
    buffer[copy_len] = '\0';
    
    // Return the number of characters actually written (excluding null terminator)
    // This respects the buffer size limit instead of returning the full formatted length
    return static_cast<int>(copy_len);
}

References args, FL_NO_EXCEPT, format(), fl::printf_detail::format_impl(), and fl::sstream::str().

Here is the call graph for this function: