Typesafe, variadic printf
[C++ std lib enhancements]

Defines
#define	Printf(A,)   vPrintf(A, (tag::Fmt,## __VA_ARGS__))
#define	fPrintf(A, B,)   vfPrintf(A,B, (tag::Fmt,## __VA_ARGS__))
#define	sPrintf(A,)   vsPrintf(A, (tag::Fmt,## __VA_ARGS__))
Functions
template<class A, class B, class C, class D>
void	tag::vfPrintf (std::basic_ostream< A, B > &o, const std::string fmt, const T_list< C, D > &l)
template<class C, class D>
void	tag::vPrintf (const std::string fmt, const T_list< C, D > &l)
template<class C, class D>
std::string	tag::vsPrintf (const std::string &fmt, const T_list< C, D > &l)
Variables
const T_ListEnd	tag::Fmt = TupleHead

---

Detailed Description

This group provides a reimplementation of the C standard library printf family of functions in a typesafe manner, using the tag::T_list tuple type.

---

Define Documentation

#define fPrintf (  A, B   )     vfPrintf(A,B, (tag::Fmt,## __VA_ARGS__))

This is the equivalent to the C-style fprintf: it provides a variadic interface and prints to give ostream. See vfPrintf for details. Parameters: A  the ostream to write to B  the format string ...  the arguments

#define Printf (  A   )     vPrintf(A, (tag::Fmt,## __VA_ARGS__))

This is the equivalent to the C-style printf: it provides a variadic interface and prints to cout. See vfPrintf for details. Parameters: A  the format string ...  the arguments

#define sPrintf (  A   )     vsPrintf(A, (tag::Fmt,## __VA_ARGS__))

This is the equivalent to the C-style sprintf: it provides a variadic interface returns the string. See vfPrintf for details. Parameters: A  the format string ...  the arguments Returns: The retulting application of fmt to the arguments

---

Function Documentation

template<class A, class B, class C, class D> void vfPrintf (  std::basic_ostream< A, B > &  o, const std::string  fmt, const T_list< C, D > &  l )

This function provides the mose generic implementation, where a typelist and an ostream can be provided. Parameters: o  ostream to print to fmt  format string l  typelist of arguments The format specifiers work much like the standard printf ones, but with some notable differences. The format is: %[flags][width][.[precision]]<conversion> Flags Flags contains zero or more of: # Alternate form: Include trailing zeros for float, use 0x or 0 prefix for hex and octal ints 0 Zero pad everything, including (oddly) strings. ' ' Space. Does nothing, I haven't figured out how to do this one. - Left justify. Overrides 0 + Always show sign for numbers Width The width is optional and must start with a non-zero digit. It seems to work even with overloaded operator<< Precision .[precision] This can mean one of two things: The precision for floating point numbers (affects all numbers in the following operator<<) The maximum width for "string" types. Truncation happens from the right. Conversion This is a single alphabetic character. This is the largets departure from the C style printf. This flag affects the "type" of the datum being formatted. Type safety still applies. Uppercase and lowercase conversions behave in exactly the same way, except uppercase ones cause uppercased output (where applicable). If a float looks like 1E6 intead of 1e6 x Make ints come out in hexadecimal o Make ints come out in octal f Make floats come out as fixed g Make floats come out in the general format e Make floats come out in exponential (scientific) format b Make bools coma out as "true" or "false" s Treat next output as string: precision means max width. k Kill (ignore) the data Differences campared to C-stype printf Unlike C, the C++ sytle printf can output values of any type for which operator<< is defined. Further, printf itself will not cause any undefined behaviour. Access beyond the end of the vargs list produces <Missing value> in the output, instead of a segfault. A malformed format string causes <Malformed format> to appear in the output followed by the remaining string including the malformed part. No further conversions are attempted after a malformed format. Note: length modifiers are not supported. See also other members of the Printf family: vPrintf vsPrintf Printf fPrintf sPrintf And list making facilities Fmt T_list Usage vfPrintf(cout, "%s, %s\n", (Fmt, "Hello", "world"));

template<class C, class D> void vPrintf (  const std::string  fmt, const T_list< C, D > &  l )

This prints to cout. See vfPrintf for details. Parameters: fmt  format string l  typelist of arguments

template<class C, class D> std::string vsPrintf (  const std::string &  fmt, const T_list< C, D > &  l )

This prints to a string. See vfPrintf for details. Parameters: fmt  format string l  typelist of arguments Returns: The resulting application of fmt to l, returned as a string

---

Variable Documentation

const T_ListEnd tag::Fmt = TupleHead [static]

List head for argument lists. This is a synonym for TupleHead Argument lists can be made by doing: (Fmt, arg1, arg2, ...)

---