A small printf-like function using variadic templates

Question

I'm looking to get some feedback on a small printf-like function I wrote that provides simplified behavior similar to boost::format:

#ifndef EXT_FORMAT_HPP__
#define EXT_FORMAT_HPP__
// ext::format
// Implements a variadic printf-like function providing behavior similar to
// boost::format
#include <regex>
#include <sstream>
#include <string>
#include <utility>
namespace {
inline std::string format_helper(
 const std::string &string_to_update, 
 const size_t) {
 return string_to_update;
}
template <typename T, typename... Args>
inline std::string format_helper(
 const std::string &string_to_update, 
 const size_t index_to_replace, 
 T &&val,
 Args &&...args) { 
 std::regex pattern{"%" + std::to_string(index_to_replace)};
 std::string replacement_string{(std::ostringstream{} << val).str()};
 return format_helper(
 std::regex_replace(string_to_update, pattern, replacement_string), 
 index_to_replace + 1, 
 std::forward<Args>(args)...);
}
} // namespace
namespace ext {
template <typename... Args>
inline std::string format(const std::string &format_string, Args &&...args) {
 return format_helper(format_string, 1, std::forward<Args>(args)...);
}
} // namespace ext
#endif

Usage example:

#include "format.hpp"
#include <iostream>
struct foo {
 int value;
 foo(int val) : value{val} {
 }
};
std::ostream &operator<<(std::ostream &os, const foo &f) {
 os << "foo(" << f.value << ")";
 return os;
}
int main() {
 double tmp = 37.382;
 std::cout << ext::format("%1 + %2 * %1 = %3", 5, tmp, 5 + tmp * 5) << std::endl;
 // Support user defined types provided the appropriate operator<< overload is defined.
 foo a_foo(55);
 std::cout << ext::format("Here is a foo constructed with 55: %1", a_foo) << std::endl;
};

This is not written to replace boost::format; it's intended to be used as a header-only include with a very limited scope. As currently written, it is possible to supply too few or too many arguments to the parameter pack. Passing too few arguments will return a string that still has format specifiers. Passing excess arguments are simply ignored and you pay the price of excess calls to std::regex_replace, which will do nothing. With that in mind, I'm looking for any and all feedback.

• countfromzero: I made some changes that hopefully makes the code easier to read. I refactored format_helper for clarity rather than trying to squeeze everything into the return call. I also renamed variables to be more descriptive and reduced all line lengths to be within 80 characters.

Answer 1

I find this to be a sweet demo, but I don't like the traps in it for the unwary. Like you mention, there is little validation of parameter counts. There is also a chance that the same location can be replaced multiple times, e.g. with a call to ext::format("%1", "%2", "%3, "%4", "hi!") resulting in "hi!". Perhaps you might consider that a bonus.

What I find most surprising in the code is this:

std::string replacement_string{(std::ostringstream{} << val).str()};

I would probably have tended towards auto replacement_string{std::to_string(val)}; or, more likely, just embedded that in the call to regex_replace. Do you do this for compatibility with existing code that provides an overload for operator<< but not to_string?

Finally, I'm torn about the use of regex. It seems like a pretty big hammer without a lot of need, here, however it does keep the code short and sweet, and implicitly avoids an infinite loop that a flawed implementation might have with ext::format("%1", "%1").

Reviewing the tests, I find the Does_Not_Alter_Format_String test to be surprising as well. I would have thought the const qualifier would indicate this well enough.

• countfromzero: I didn't know about std::to_string overloading! I did it primarily to support any class that overloads operator<<. Thank you for the feedback!
• Toby Speight: I believe it would be possible to just call to_string(val), and provide a template ext::to_string() that uses <<, for those classes without their own to_string().

Answer 2

FTBFS

This code doesn't compile here (GCC 9.2, -std=c++2a):

29935.cpp:24:64: error: ‘class std::basic_ostream<char>’ has no member named ‘str’
 24 | std::string replacement_string{(std::ostringstream{} << val).str()};
 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~

I had to expand that to keep a reference to the concrete class:

 std::ostringstream stream{};
 stream << val;
 std::string replacement_string{stream.str()};

Major

We can pass %% to std::sprintf() to produce a single %%, but that doesn't work here, so there's no way for the format string to specify a literal %1 to output.

Very minor

There's a stray ; after the definition of main() in the test program.