printf ("%#p [ buf ] (%.2d) : %s \n", buf, strlen (buf), buf);
I never see %#p (%.2d) before,how does it work?
From http://www.cplusplus.com/reference/clibrary/cstdio/printf/:
Used with o, x or X specifiers the value is preceeded with 0, 0x or 0X respectively for values different than zero.
Used with e, E and f, it forces the written output to contain a decimal point even if no digits would follow. By default, if no digits follow, no decimal point is written.
Used with g or G the result is the same as with e or E but trailing zeros are not removed.
So it seems to do nothing in your case, since p is used to print a pointer address. I guess some compilers might interpret this differently, but I can't find any mention of it.
p specifies to print an address (i.e. a pointer). The # flag specifies "alternate form", which in this case, probably prepends 0x to the output.
It's a flag for the format identifier.
It will more than likely print out 0x before the pointed value (but I have not checked TBH)
A good explanation is found here
Not sure if that is a valid use of the '#' flag:
Used with o, x or X specifiers the
value is preceeded with 0, 0x or 0X
respectively for values different
than zero.
Used with e, E and f, it
forces the written output to contain
a decimal point even if no digits
would follow. By default, if no
digits follow, no decimal point is
written.
Used with g or G the result
is the same as with e or E but
trailing zeros are not removed.
It will most likely print an alternately formatted form for the pointer, appending 0x to the address.
In your case (p conversion) the result is undefined according to the man page. Anyway, %p and %#p prints the same value on my machine (looks like 0x7FFFF000)
Related
#include <stdio.h>
int main()
{
float x;
x=(int)(float)(double)(5.5);
printf("%#u",x);
return 0;
}
How the # flag in the printf is working here?
Everytime I run this code I get different(garbage) values.
I know that the # flag works only with o , 0x, 0X, e, E, f, g, G but when it is not defined for integers.
So is this an Undefined behaviour? I am getting correct values when I am using the above flags.
So tell me whether I am right or wrong.
From c11 standard.
7.21.6.1. p6:
#:
The result is converted to an ‘‘alternative form’’. For o conversion, it increases
the precision, if and only if necessary, to force the first digit of the result to be a
zero (if the value and precision are both 0, a single 0 is printed). For x (or X)
conversion, a nonzero result has 0x (or 0X) prefixed to it. For a, A, e, E, f, F, g,
and G conversions, the result of converting a floating-point number always
contains a decimal-point character, even if no digits follow it. (Normally, a
decimal-point character appears in the result of these conversions only if a digit
follows it.) For g and G conversions, trailing zeros are not removed from the
result. For other conversions, the behavior is undefined.
So, to clarify, using # with u is undefined.
From the manual page:
#
The value should be converted to an "alternate form" [...] For other conversions, the result is undefined.
So yes, it's undefined.
Using this flag with any other than the listed conversions is undefined behaviour. Don't use it with other conversions.
The value should be converted to an "alternate form".
For o conversions, the first character of the output string is made zero (by prefixing a 0 if it was not zero already).
For x and X conversions, a nonzero result has the string "0x" (or "0X" for X conversions) prepended to it.
For a, A, e, E, f, F, g, and G conversions, the result will always contain a decimal point, even if no digits follow it (normally, a decimal point appears in the results of those conversions only if a digit follows).
For g and G conversions, trailing zeros are not removed from the result as they would otherwise be.
For other conversions, the result is undefined.
(taken from the printf(3)-manpage. Wording is essentially the same as in the standard. Emphasis mine)
Please explain the output. What does %.#s in printf() mean?
#include<stdio.h>
#include <stdlib.h>
int main(int argc,char*argv[]){
char *A="HELLO";
printf("%.#s %.2s\n",A,A);
return 0;
}
OUTPUT:
#s HE
It's undefined behavior. # in printf format specifier means alternative form, but according to the standard, # is only used together with o, a, A, x, X, e, E, f, F, g, G, not including s.
C11 §7.21.6.1 The fprintf function Section 6
# The result is converted to an ‘‘alternative form’’. For o conversion, it increases
the precision, if and only if necessary, to force the first digit of the result to be a
zero (if the value and precision are both 0, a single 0 is printed). For x (or X)
conversion, a nonzero result has 0x (or 0X) prefixed to it. For a, A, e, E, f, F, g, and G conversions, the result of converting a floating-point number always
contains a decimal-point character, even if no digits follow it. (Normally, a decimal-point character appears in the result of these conversions only if a digit follows it.) For g and G conversions, trailing zeros are not removed from the result. For other conversions, the behavior is undefined.
For example, on my machine, output is different: %.0#s HE
%.1s is used to print the first character of the string
%.2s is used to print the first two characters of the string
%.3s is used to print the first three characters of the string and so on
where # : alternative form of the conversion is performed is a flag which have an optional usage with the format parameter in printf() and fprintf() functions etc.
But as #Yu Hao said # is only used together with o, a, A, x, X, e, E, f, F, g, G, not including s.
in your case %.#s usage is Wrong.
Example usage from reference given by #WhozCraig :
printf("Hexadecimal:\t%x %x %X %#x\n", 5, 10, 10, 6);
printf("Octal:\t%o %#o %#o\n", 10, 10, 4);
I agree with Yu Hao's answer that it is undefined behavior, but I think the reason is different. Yes, the # character works as a flag to convert the result to an alternative format. Yes, the # flag is undefined for strings. But in this case, the # is not a flag, it's a precision. It's still undefined, but the reason is different
The C11 standard at §6.21.6.1 says that the % sign is followed in sequence by:
Zero or more flags (including #)
An optional minimum field width
An optional precision
An optional length modifier
A conversion specifier character
Except for the conversion specifier, these are all optional. But the order in which they appear is always as above. So flag, if present, has to be first, immediately after the % character. Here what follows the % is not something indicating a flag, it is a period: %., indicating precision.
When you have %.# in your format string for printf(), the period indicates that the following character is the precision for the conversion specification that follows. I.e., the # in your code specifies the precision for the string s, not a flag. To be a flag, it would have to directly follow the % character, without the intervening period.
With regard to precision, the C standard §7.21.6.1 says this:
The precision takes the form of a period (.) followed either by an asterisk *
(described later) or by an optional decimal integer; if only the period is specified,
the precision is taken as zero. If a precision appears with any other conversion
specifier, the behavior is undefined.
Since in your format string you have %.#s, and # is neither an asterisk * nor a decimal integer, the result is undefined.
So to be extremely exact about why your code is undefined, I think it's because the # character appears in place of a legal precision, not because it is an illegal flag for the %s conversion. It would be illegal as a flag, of course, but that's not what is precisely (har har) happening here.
I came up with a code
#include <stdio.h>
int main()
{
int i = 1427;
double d = 1427.0;
printf("%#o\n", i);
printf("%#X\n", i);
printf("\n%g\n", d);
printf("%#g\n", d);
return 0;
}
which is giving the output:
02623
0X593
1427
1427.00
First I thought # is used for prefixing 0 to the output but I was wrong because of its strange behavior in last output in which it is printing zeroes after decimal.
Could someone explain what this #is and what it is doing here?
The # flag has a different behavior, depending on context.
If it is used with the o, x, or X specifiers, the value is preceded with 0, 0x, or 0X respectively.
If it is used with a/A, e/E, f/F, or G, the value always ends with a decimal point.
This behavior is quite well documented multiple places on the web. Searching for "printf" and possibly "format specifiers" will generally turn up lots of good links. Here are a few to whet your appetite:
http://en.wikipedia.org/wiki/Printf_format_string#Format_placeholders
http://www.cplusplus.com/reference/cstdio/printf/
http://en.cppreference.com/w/cpp/io/c/fprintf
http://msdn.microsoft.com/en-us/library/56e442dc.aspx
From the POSIX man pages man 3p printf:
#: Specifies that the value is to be converted to an alternative form. For o conversion, it increases the precision (if necessary) to force
the first digit of the result to be zero. For x or X conversion specifiers, a non-zero result shall have 0x (or 0X) prefixed to it. For a,
A, e, E, f, F, g, and G conversion specifiers, the result shall always contain a radix character, even if no digits follow the radix charac‐
ter. Without this flag, a radix character appears in the result of these conversions only if a digit follows it. For g and G conversion
specifiers, trailing zeros shall not be removed from the result as they normally are. For other conversion specifiers, the behavior is
undefined.
Putting it simple: it prints the alternative format, whatever it is. For hex. values, it is prefixing 0x, for octal 0, and for floating points, it forces some decimal rules...
I think that if you read about C's printf function here, you'll be able to further understand things such as "#", among others.
Used with o, x or X specifiers the value is preceeded with 0, 0x or 0X
respectively for values different than zero. Used with a, A, e, E, f,
F, g or G it forces the written output to contain a decimal point even
if no more digits follow. By default, if no digits follow, no decimal
point is written.
Exerpt from wikipedia:
# Alternate form. For 'g' and 'G', trailing zeros are not removed. For 'f', 'F', 'e', 'E', 'g', 'G', the output always contains a decimal point. For 'o', 'x', and 'X', a 0, 0x, and 0X, respectively, is prepended to non-zero numbers.
%#o (Octal) 0 prefix inserted.
%#x (Hex) 0x prefix added to non-zero values.
%#X (Hex) 0X prefix added to non-zero values.
%#g Always show the decimal point trailing
zeros not removed.
Zeroes are bound to come after decimal because you are using %#g.
I understand %#x give the same effect of 0x%x and it meets POSIX standard. But people mention that some compilers do not support it. Is that true, any example?
Aside from perhaps some broken embedded-systems C libraries, the # modifier should be universally supported. However %#x and 0x%x are not the same. They yield different results for the value 0, and the # modifier will always print the x in the same case as the hex digits (e.g. %#x gives 0xa and %#X gives 0XA) while using 0x%X would allow you to have a lowercase x and capital hex digits (much more visually pleasing, at least to me). As such, I find the # modifier is rarely useful in practice.
%#x is a valid conversion specification in printf format string in C89, C99 and C11.
The # flag character is not from POSIX, but rather the C standard (§7.21.6.1). If a compiler or library does not support it then it is not a C compiler / standard library.
This is perfectly valid as per C Specification - 7.21.6.1 The fprintf function - point #6
#
The result is converted to an ‘‘alternative form’’. For o conversion, it increases
the precision, if and only if necessary, to force the first digit of the result to be a
zero (if the value and precision are both 0, a single 0 is printed). For x (or X)
conversion, a nonzero result has 0x (or 0X) prefixed to it. For a, A, e, E, f, F, g,
and G conversions, the result of converting a floating-point number always
contains a decimal-point character, even if no digits follow it. (Normally, a
decimal-point character appears in the result of these conversions only if a digit
follows it.) For g and G conversions, trailing zeros are not removed from the
result. For other conversions, the behavior is undefined.
#include<stdio.h>
int main ()
{
printf("%#04x",50);
}
Some one showed me above code and I could not understand it since I do have used printf in C programs but above sort of use I saw in my life for the first time.
Why did above code prints output as
0x32
Can some one give me a link or reference to some thing so that I can understand it better.
From the printf(3) manual page:
The flag characters
The character % is followed by zero or more of the following flags:
# — The value should be converted to an "alternate form". For o conversions, the first character of the output string is made zero (by prefixing a 0 if it was not zero already). For x and X conversions, a nonzero result has the string "0x" (or "0X" for X conversions) prepended to it. For a, A, e, E, f, F, g, and G conversions, the result will always contain a decimal point, even if no digits follow it (normally, a decimal point appears in the results of those conversions only if a digit follows). For g and G conversions, trailing zeros are not removed from the result as they would otherwise be. For other conversions, the result is undefined.
Other flags omitted...
Thus, %# prepends "0x" to the output since the output format is x. The 0 is there to use 0 (zeros) for padding. Then the number 4 says the total number of characters to print is four. Had the number 4 been exchanged with 10, the output would have been 0x00000032 – a total of 10 characters.
50 decimal is 32 hexadecimal.
Apart from that, the documentation should tell you all you need to know.
Because %x formats the given value into hexadecimal.
In facts, 0x32 (hex) == 50 (decimal).
This is a good primer for reference.