printf

Writes the results to a file stream stream.

The format string consists of whitespace characters, non-whitespace characters (except %) and conversion specifications. Each conversion specification has the following format:

%[flags][width][.precision][length]specifier

Flags:

Character	Description
+	The sign of signed conversions is always prepended to the result of the conversion
<space>	if the result of a signed conversion does not start with a sign character, or is empty, space is prepended to the result. It is ignored if + flag is present.
-	The result of the conversion is left-justified within the field
#	Alternative form of the conversion is performed.
0	Use 0 instead of spaces for padding when width is specified

Width:

Integer value or * that specifies minimum field width. The result is padded with space characters (by default), if required, on the left when right-justified, or on the right if left-justified. In the case when * is used, the width is specified by an additional argument of type int. If the value of the argument is negative, it results with the - flag specified and positive field width.

Precision:

. followed by integer number or * that specifies precision of the conversion. In the case when * is used, the precision is specified by an additional argument of type int. If the value of this argument is negative, it is ignored.

Length:

Character	Description
hh	char
h	short
l	long
ll	long-long
L	long double
z	sizue_t
j	intmax_t
t	ptrdiff_t

Specifier:

specifier	Output	Example
a	Floating point, hexadecimal, lowercase	-0xc.90fep-2
A	Floating point, hexadecimal, uppercase	-0XC.90FEP-2
c	Character	c
d, i	integer	251
e	Mantissa/exponent (scientific), lowercase	2.5121e+2
E	Mantissa/exponent (scientific), uppercase	2.5121E+2
f	Floating point, decimal, lowercase	2.32
F	Floating point, decimal, uppercase	2.32
g	Floating point, shortest representation (%e or %f)	512.23
G	Floating point, shortest representation (%E or %F)	512.23
n	Nothing
o	Octal	320
p	Pointer address	b2010020
s	String	my str
u	Decimal integer	93535
x	Integer, hexadecimal, lowercase	3ab
X	Integer, hexadecimal, uppercase	3AB
%	%% to output %	%

Examples:

Format:	Parameters:	Output:
"Characters:\t%c %%\n"	65	"Characters: A %"
"Decimal:\t%i %d %.6i %i %.0i %+i %u\n"	1, 2, 3, 0, 0, 4, -1	"Decimal: 1 2 000003 0 +4 4294967295"
"Hexadecimal:\t%x %x %X %#x\n"	5, 10, 10, 6	"Hexadecimal: 5 a A 0x6"
"Octal:\t%o %#o %#o\n"	10, 10, 4	"Octal: 12 012 04"
"Rounding:\t%f %.0f %.32f\n"	1.5, 1.5, 1.3	"Rounding: 1.500000 2 1.30000000626"
"Padding:\t%05.2f %.2f %5.2f\n"	1.5, 1.5, 1.5	"Padding: 01.50 1.50 1.50"
"Scientific:\t%E %e\n"	1.5, 1.5	"Scientific: 1.500000E+00 1.500000e+00"
"Hexadecimal:\t%a %A\n"	1.5, 1.5	"Hexadecimal: 0x1.8p+0 0X1.8P+0"

Example: Write a formatted string to the stream:

public static int main (string[] args) {
	string mystr = "mystr";
	short myshort = 3;
	ushort myushort = 3;
	int myint = -10;
	uint myuint = 10;
	long mylong = 100;
	long myulong = 100;
	float myfloat = 0.10f;
	char mychar = 'a';
	char myuchar = 'a';
	unichar myunichar = 'z';
	void* myptr = null;
	bool mybool = true;
	size_t mysizet = 10;
	ssize_t myssizet = 10;
	int8 myint8 = 2;
	uint8 myuint8 = 2;
	int16 myint16 = 2;
	uint16 myuint16 = 2;
	int32 myint32 = 2;
	uint32 myuint32 = 2;
	int64 myint64 = 2;
	uint64 myuint64 = 2;

	// Output:
	// `` 1. ptr: (nil)``
	// `` 2. percent: % 3. string: mystr``
	print (" 1. ptr: %p\n", myptr);
	print (" 2. percent: %%\n");

	// Output:
	// `` 3. string: mystr``
	// `` 4. char: 97``
	// `` 5. uchar: 97``
	// `` 6. unichar: z
	print (" 3. string: %s\n", mystr);
	print (" 4. char: %d\n", mychar);
	print (" 5. uchar: %hhu\n", myuchar);
	print (" 6. unichar: %s\n", myunichar.to_string ());

	// Output:
	// `` 7. short: 3``
	// `` 8. ushort: 3``
	print (" 7. short: %hi\n", myshort);
	print (" 8. ushort: %hu\n", myushort);

	// Output:
	// `` 9. int8: 2``
	// ``10. uint8: 2``
	print (" 9. int8: %hhi\n", myint8);
	print ("10. uint8: %hhu\n", myuint8);

	// Output:
	// ``11. int16: 2``
	// ``12. uint16: 2``
	print ("11. int16: %" + int16.FORMAT + "\n", myint16);
	print ("12. uint16: %" + uint16.FORMAT + "\n", myuint16);

	// Output:
	// ``13. int32: 2``
	// ``14. uint32: 2``
	print ("13. int32: %" + int32.FORMAT + "\n", myint32);
	print ("14. uint32: %" + uint32.FORMAT + "\n", myuint32);

	// Output:
	// ``15. int64: 2``
	// ``16. uint64: 2``
	print ("15. int64: %" + int64.FORMAT + "\n", myint64);
	print ("16. uint64: %" + uint64.FORMAT + "\n", myuint64);

	// Output:
	// ``17. int: -10``
	// ``18. int: -10``
	// ``19. octal: 37777777766``
	// ``20. hex,lower: fffffff6``
	// ``21. hex,upper: FFFFFFF6``
	// ``22. uint: 10``
	print ("17. int: %d\n", myint);
	print ("18. int: %i\n", myint);
	print ("19. octal: %o\n", myint);
	print ("20. hex,lower: %x\n", myint);
	print ("21. hex,upper: %X\n", myint);
	print ("22. uint: %u\n", myuint);

	// Output:
	// ``23. long: 100``
	// ``24. ulong: 100``
	print ("23. long: %li\n", mylong);
	print ("24. ulong: %lu\n", myulong);

	// Output:
	// ``25. size_t: 10``
	// ``26. ssize_t: 10``
	print ("25. size_t: %" + size_t.FORMAT + "\n", mysizet);
	print ("26. ssize_t: %" + ssize_t.FORMAT + "\n", myssizet);

	// Output:
	// ``27. float,lower: 0.100000``
	// ``28. float,upper: 0.100000``
	// ``29. scientific,lower: 1.000000e-01``
	// ``30. scientific,upper: 1.000000E-01``
	// ``31. shortest,lower: 0.1``
	// ``32. shortest,upper: 0.1``
	// ``33. hex,lower: 0x1.99999ap-4``
	// ``34. hex,upper: 0X1.99999AP-4``
	print ("27. float,lower: %f\n", myfloat);
	print ("28. float,upper: %F\n", myfloat);
	print ("29. scientific,lower: %e\n", myfloat);
	print ("30. scientific,upper: %E\n", myfloat);
	print ("31. shortest,lower: %g\n", myfloat);
	print ("32. shortest,upper: %G\n", myfloat);
	print ("33. hex,lower: %a\n", myfloat);
	print ("34. hex,upper: %A\n", myfloat);

	// Output:
	// ``35. true``
	print ("35. %s\n", mybool.to_string ());
	return 0;
}

valac --pkg glib-2.0 GLib.FileStream.printf.vala

Parameters:

format	a string specifying how to interpret the data. (See GLib.FileStream.printf)
...	variable argument list containing the data to print.