faqcat1d60.html

this is a mirrored site c-faq. thought might need offline

<hr><hr><hr>
<a name="printfvwid">
<h1>
comp.lang.c FAQ list
<font color=blue>&middot;</font>
<a href="../../stdio/printfvwid.html"><!-- qtag -->Question 12.10</a>
</h1>
<p>
<font face=Helvetica size=8 color=blue><b>Q:</b></font>
How can I implement a variable field width with <TT>printf</TT>?
That is, instead of
something like
<TT>%8d</TT>,
I want the width to be specified
at run time.
</p><p><hr>
<p>
<font face=Helvetica size=8 color=blue><b>A:</b></font>
<TT>printf("%*d", width, x)</TT>
will do just what you want.
The asterisk
in the format specifier
indicates that
an
<TT>int</TT> value from the argument list
will be used for the
field
width.
(Note that
in
the argument list,
the width
precedes

the value to be printed.)
See also question <a href="faqcat1d60.html?sec=stdio#scanfvwid">12.15</a>.
</p>




<p>References:

K&amp;R1 Sec. 7.3
<br>
K&amp;R2 Sec. 7.2
<br>
ISO Sec. 7.9.6.1
<br>
H&amp;S Sec. 15.11.6
<br>
CT&amp;P Sec. A.1
<hr><hr><hr>
<a name="commaprint">
<h1>
comp.lang.c FAQ list
<font color=blue>&middot;</font>
<a href="../../stdio/commaprint.html"><!-- qtag -->Question 12.11</a>
</h1>
<p>
<font face=Helvetica size=8 color=blue><b>Q:</b></font>
How can I print numbers with commas separating the thousands?
<br>What about currency formatted numbers?
</p><p><hr>
<p>
<font face=Helvetica size=8 color=blue><b>A:</b></font>
The functions in <TT>&lt;locale.h&gt;</TT>
begin to provide some support
for these operations,
but
there
is no standard C function
for doing either
task.
(In Standard C, the only thing <TT>printf</TT> does
in response to a custom locale setting
is to change its

decimal-point character.)
</p><p>
POSIX specifies a <TT>strfmon</TT> function for formatting monetary quantities
in a locale-appropriate way,
and that the apostrophe flag in a numeric <TT>printf</TT> format specifier
(e.g. <TT>%'d</TT>, <TT>%'f</TT>)
requests comma-separated digits.
</p><p>Here is a little routine for formatting comma-separated numbers,
using the locale's thousands separator, if available:
<pre>
#include &lt;locale.h&gt;

char *commaprint(unsigned long n)
{
	static int comma = '\0';
	static char retbuf[30];
	char *p = &amp;retbuf[sizeof(retbuf)-1];
	int i = 0;

	if(comma == '\0') {
		struct lconv *lcp = localeconv();
		if(lcp != NULL) {
			if(lcp-&gt;thousands_sep != NULL &amp;&amp;
				*lcp-&gt;thousands_sep != '\0')
				comma = *lcp-&gt;thousands_sep;
			else	comma = ',';
		}
	}

	*p = '\0';

	do {
		if(i%3 == 0 &amp;&amp; i != 0)
			*--p = comma;
		*--p = '0' + n % 10;
		n /= 10;
		i++;
	} while(n != 0);

	return p;
}
</pre>

(A better implementation would use
the <TT>grouping</TT> field of
the <TT>lconv</TT> structure,
rather than assuming groups of three digits.
A safer size for <TT>retbuf</TT> might be
<TT>4*(sizeof(long)*CHAR_BIT+2)/3/3+1</TT>;
see question <a href="faqcat1d60.html?sec=stdio#sprintfsize">12.21</a>.)
</p>

<p>References:

ISO Sec. 7.4
<br>
H&amp;S Sec. 11.6 pp. 301-4
<hr><hr><hr>
<a name="scanf1">
<h1>
comp.lang.c FAQ list
<font color=blue>&middot;</font>
<a href="../../stdio/scanf1.html"><!-- qtag -->Question 12.12</a>
</h1>
<p>
<font face=Helvetica size=8 color=blue><b>Q:</b></font>
Why doesn't the call
<TT>scanf("%d", i)</TT>
work?
</p><p><hr>
<p>
<font face=Helvetica size=8 color=blue><b>A:</b></font>



The
arguments you
pass to <TT>scanf</TT>
must always be
pointers:
for each value converted,
<TT>scanf</TT> ``returns'' it
by filling in one of the locations

you've passed pointers to.
(See also question <a href="faqcat38c2.html?sec=misc#multretval">20.1</a>.)
To fix
the fragment above,
change it to

<TT>scanf("%d",&nbsp;&amp;i)</TT>
.
<hr><hr><hr>
<a name="scanf1a">
<h1>
comp.lang.c FAQ list
<font color=blue>&middot;</font>
<a href="../../stdio/scanf1a.html"><!-- qtag -->Question 12.12b</a>
</h1>
<p>
<font face=Helvetica size=8 color=blue><b>Q:</b></font>
Why <em>does</em> the call
<pre>
char s[30];
scanf("%s", s);</pre>

work?
I thought you always needed an <TT>&amp;</TT>
on each variable passed to <TT>scanf</TT>.
</p><p><hr>
<p>
<font face=Helvetica size=8 color=blue><b>A:</b></font>
You always need a <em>pointer</em>;
you don't necessarily need an explicit <TT>&amp;</TT>.
When you pass an array to <TT>scanf</TT>,
you do not need
the <TT>&amp;</TT>,
because
arrays
are
always
passed to functions as pointers,
whether you use <TT>&amp;</TT> or not.
See questions <a href="faqcatca65.html?sec=aryptr#aryptrequiv">6.3</a>
and <a href="faqcatca65.html?sec=aryptr#aryptrparam">6.4</a>.
(If you did use an explicit <TT>&amp;</TT>,
you'd get the wrong type of pointer;
see question <a href="faqcatca65.html?sec=aryptr#aryvsadr">6.12</a>.)
<hr><hr><hr>
<a name="scanf2">
<h1>
comp.lang.c FAQ list
<font color=blue>&middot;</font>
<a href="../../stdio/scanf2.html"><!-- qtag -->Question 12.13</a>
</h1>
<p>
<font face=Helvetica size=8 color=blue><b>Q:</b></font>
Why doesn't
this code:
<pre>
double d;
scanf("%f", &amp;d);</pre>

work?
</p><p><hr>
<p>
<font face=Helvetica size=8 color=blue><b>A:</b></font>
Unlike

<TT>printf</TT>,
<TT>scanf</TT> uses <TT>%lf</TT> for
values of type
<TT>double</TT>, and <TT>%f</TT> for <TT>float</TT>.
<a href="../../stdio/fpfmts2.html" rel=subdocument>[footnote]</a>
<TT>%f</TT> tells <TT>scanf</TT> to expect a pointer-to-<TT>float</TT>,
not the pointer-to-<TT>double</TT> you gave it.
Either use <TT>%lf</TT>,
or
declare the
receiving
variable as a <TT>float</TT>.
See also question <a href="faqcat1d60.html?sec=stdio#scanfvsprintf">12.9</a>.
<hr><hr><hr>
<a name="scanfh">
<h1>
comp.lang.c FAQ list
<font color=blue>&middot;</font>
<a href="../../stdio/scanfh.html"><!-- qtag -->Question 12.14</a>
</h1>
<p>
<font face=Helvetica size=8 color=blue><b>Q:</b></font>
Why doesn't the code
<pre>
short int s;
scanf("%d", &amp;s);</pre>

work?
</p><p><hr>
<p>
<font face=Helvetica size=8 color=blue><b>A:</b></font>
When converting <TT>%d</TT>,
<TT>scanf</TT> expects a pointer to an <TT>int</TT>.
To convert to a <TT>short&nbsp;int</TT>, use <TT>%hd</TT>
.
(See also the table in question <a href="faqcat1d60.html?sec=stdio#scanfvsprintf">12.9</a>.)
<hr><hr><hr>
<a name="scanfvwid">
<h1>
comp.lang.c FAQ list
<font color=blue>&middot;</font>
<a href="../../stdio/scanfvwid.html"><!-- qtag -->Question 12.15</a>
</h1>
<p>
<font face=Helvetica size=8 color=blue><b>Q:</b></font>
How can I specify a variable width in a <TT>scanf</TT> format string?
</p><p><hr>
<p>
<font face=Helvetica size=8 color=blue><b>A:</b></font>
You can't;
an asterisk
in a <TT>scanf</TT>
format string
means to suppress assignment.
You
may be able to
use ANSI
stringizing and
string concatenation
to construct a constant format specifier
based on a preprocessor macro containing the desired width:
<pre>
#define WIDTH 3

#define Str(x) #x
#define Xstr(x) Str(x)	/* see question <a href="faqcat7d4b.html?sec=ansi#stringize">11.17</a> */

scanf("%" Xstr(WIDTH) "d", &amp;n);
</pre>
If the width is a run-time variable,
though,
you'll have to
build the format specifier at run time, too:
<pre>
char fmt[10];
sprintf(fmt, "%%%dd", width);
scanf(fmt, &amp;n);
</pre>
(<TT>scanf</TT> formats like these
are unlikely when reading from standard input,
but might find some usefulness
with <TT>fscanf</TT> or <TT>sscanf</TT>.)
</p><p>See also questions <a href="faqcat7d4b.html?sec=ansi#stringize">11.17</a> and <a href="faqcat1d60.html?sec=stdio#printfvwid">12.10</a>.
<hr><hr><hr>
<a name="datafmts">
<h1>
comp.lang.c FAQ list
<font color=blue>&middot;</font>
<a href="../../stdio/datafmts.html"><!-- qtag -->Question 12.16</a>
</h1>
<p>
<font face=Helvetica size=8 color=blue><b>Q:</b></font>
How can I read data from
data files with particular formats?
<br>How can I read ten floats without having to use a jawbreaker 
<TT>scanf</TT> format
<br>like
<TT>"%f&nbsp;%f&nbsp;%f&nbsp;%f&nbsp;%f&nbsp;%f&nbsp;%f&nbsp;%f&nbsp;%f&nbsp;%f"</TT>?
<br>How can I read an arbitrary number of fields from a line into an array?
</p><p><hr>
<p>
<font face=Helvetica size=8 color=blue><b>A:</b></font>
In general, there are three

main ways
of parsing data lines:
</p><OL><li>Use
<TT>fscanf</TT> or <TT>sscanf</TT>,
with
an appropriate format string.
Despite the limitations
mentioned in this section
(see question <a href="faqcat1d60.html?sec=stdio#scanfprobs">12.20</a>),
the <TT>scanf</TT> family is quite powerful.
Though whitespace-separated fields are always the easiest to 
deal with,
<TT>scanf</TT> format strings can also be used
with more 
compact,
column oriented, FORTRAN-style data.
For instance, the line
<pre>
	1234ABC5.678
</pre>
could be
read
with <TT>"%d%3s%f"</TT>.
(See also the last example in question <a href="faqcat1d60.html?sec=stdio#scanfjam">12.19</a>.)
<li>Break the line into
fields separated by
whitespace
(or some other delimiter),
using <TT>strtok</TT> or the equivalent
(see question <a href="faqcat1067.html?sec=lib#strtok">13.6</a>),
then deal with each field individually,
perhaps with functions like <TT>atoi</TT>
and <TT>atof</TT>.
(Once the line is broken up,
the code for handling the fields
is much like the traditional code in <TT>main()</TT>
for handling the <TT>argv</TT> array;
see question <a href="faqcat38c2.html?sec=misc#argv">20.3</a>.)
This method is particularly useful
for reading an arbitrary
(i.e. not known in advance)
number
of fields from a line into an array.
<p>Here is a simple example
which copies a line of
up to 10
floating-point numbers



(separated by whitespace)
into an array:
<pre>
#define MAXARGS 10

char line[] = "1 2.3 4.5e6 789e10";
char *av[MAXARGS];
int ac, i;
double array[MAXARGS];

ac = makeargv(line, av, MAXARGS);
for(i = 0; i &lt; ac; i++)
	array[i] = atof(av[i]);
</pre>

(See question <a href="faqcat1067.html?sec=lib#strtok">13.6</a>
for the definition of <TT>makeargv</TT>.)
</p><li>Use whatever pointer manipulations
and library routines
are handy
to parse the line in an
ad-hoc way.
(The ANSI <TT>strtol</TT> and <TT>strtod</TT> functions
are particularly useful for this style of parsing,
because they can return a pointer
indicating where they stopped reading.)
This

is obviously the most general way,
but it's also the most difficult and error-prone:
the
thorniest
parts
of
many
C programs
are
those which use lots of
tricky
little pointers to pick apart strings.
</OL><p>When
possible, design data files and input formats
so that they don't require arcane manipulations,
but
can
instead
be parsed with easier techniques
such as 1 and 2:
dealing with the files will
then

be
much more pleasant
all around.
<hr><hr><hr>
<a name="scanfhang">
<h1>
comp.lang.c FAQ list
<font color=blue>&middot;</font>
<a href="../../stdio/scanfhang.html"><!-- qtag -->Question 12.17</a>
</h1>
<p>
<font face=Helvetica size=8 color=blue><b>Q:</b></font>
When I read
numbers
from the keyboard with

<TT>scanf</TT>
and a
<TT>"%d\n"</TT>
format,
like this:
<pre>
	int n;
	scanf("%d\n", &amp;n);
	printf("you typed %d\n", n);
</pre>

it seems to hang until I type one extra line of input.
</p><p><hr>
<p>
<font face=Helvetica size=8 color=blue><b>A:</b></font>
Perhaps surprisingly,

<TT>\n</TT>
in a
<TT>scanf</TT>
format string

does
<em>not</em>
mean
to expect a newline,
but rather
to read and discard characters
as long as each is a whitespace character.
(In fact,
any whitespace character in a <TT>scanf</TT> format string
means to read and discard whitespace characters.
<a href="../../stdio/krerr.html" rel=subdocument>[footnote]</a>
Furthermore, formats like <TT>%d</TT> also discard leading 
whitespace,
so you usually don't need
explicit
whitespace in <TT>scanf</TT> format strings
at all.)
</p><p>The <TT>\n</TT> in <TT>"%d\n"</TT>
therefore
causes <TT>scanf</TT> to read characters
until it finds a non-whitespace character,
and it may need to read another line
before it can find that non-whitespace character.
In this case, the fix is just to use <TT>"%d"</TT>,
without the <TT>\n</TT>



(athough
your program may
then
need to skip over the unread newline;
see question <a href="faqcat1d60.html?sec=stdio#scanfinterlace">12.18a</a>).
</p><p><TT>scanf</TT> was designed for free-format input,
which is seldom what you want when reading from the keyboard.
By ``free format''
we mean that <TT>scanf</TT> does not treat newlines differently
from
other whitespace.
The format <TT>"%d&nbsp;%d&nbsp;%d"</TT>
would be equally happy
reading the input
<pre>
	1 2 3
</pre>
or
<pre>
	1
	2
	3
</pre>
</p><p>(By way of comparison,