faqcatd3c2.html

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

(In other words, an undocumented but otherwise global symbol
with a name matching that prefix
is, by convention, ``private.'')
<li>Use a name beginning with an underscore,
since such names shouldn't be used by ordinary code.
(See question <a href="faqcatd3c2.html?sec=decl#namespace">1.29</a> for more information,
and
for

a description of the ``no man's land''
between the user and implementation namespaces.)
</OL></p><p>It may also be possible to use special linker
invocations
to adjust the visibility of names,
but any such
techniques
are outside of the scope of the C language.
<hr><hr><hr>
<a name="static">
<hr><hr><hr>
<a name="extern">
<h1>
comp.lang.c FAQ list
<font color=blue>&middot;</font>
<a href="../../decl/extern.html"><!-- qtag -->Question 1.11</a>
</h1>
<p>
<font face=Helvetica size=8 color=blue><b>Q:</b></font>
What does <TT>extern</TT> mean in a function declaration?
</p><p><hr>
<p>
<font face=Helvetica size=8 color=blue><b>A:</b></font>
<TT>extern</TT> is


significant
only
with data declarations.
In function declarations,
it
can be used as a stylistic hint
to indicate that the function's definition
is probably in another source file,
but there is no formal
difference
between
<pre>
	extern int f();
</pre>
and
<pre>
	int f();
</pre>
</p><p>See also question
<a href="faqcatd3c2.html?sec=decl#static">1.10</a>.
</p>




<p>References:

ISO Sec. 6.1.2.2, Sec. 6.5.1
<br>
Rationale Sec. 3.1.2.2
<br>
H&amp;S Secs. 4.3,4.3.1 pp. 75-6
<hr><hr><hr>
<a name="auto">
<h1>
comp.lang.c FAQ list
<font color=blue>&middot;</font>
<a href="../../decl/auto.html"><!-- qtag -->Question 1.12</a>
</h1>
<p>
<font face=Helvetica size=8 color=blue><b>Q:</b></font>
What's the <TT>auto</TT> keyword good for?
</p><p><hr>
<p>
<font face=Helvetica size=8 color=blue><b>A:</b></font>
Nothing;
it's archaic.
<a href="../../decl/fn3.html" rel=subdocument>[footnote]</a>
(It's a holdover from
C's
typeless
predecessor language B,

where in the absence of



keywords like <TT>int</TT>
a declaration always needed a storage class.)
See also question
<a href="faqcat38c2.html?sec=misc#entry">20.37</a>.
</p>




<p>References:

K&amp;R1 Sec. A8.1 p. 193
<br>
ISO Sec. 6.1.2.4, Sec. 6.5.1
<br>
H&amp;S Sec. 4.3 p. 75, Sec. 4.3.1 p. 76
<hr><hr><hr>
<a name="typedefvsdefine">
<h1>
comp.lang.c FAQ list
<font color=blue>&middot;</font>
<a href="../../decl/typedefvsdefine.html"><!-- qtag -->Question 1.13</a>
</h1>
<p>
<font face=Helvetica size=8 color=blue><b>Q:</b></font>
What's the difference between using a <TT>typedef</TT>
or

a <TT>#define</TT>
for a user-defined type?
</p><p><hr>
<p>
<font face=Helvetica size=8 color=blue><b>A:</b></font>
In general, <TT>typedef</TT>s are preferred,
in part because they can correctly encode pointer types.
For example,
consider these declarations:

<pre>
	typedef char *String_t;
	#define String_d char *
	String_t s1, s2;
	String_d s3, s4;
</pre>
<TT>s1</TT>, <TT>s2</TT>, and <TT>s3</TT> are all declared as <TT>char&nbsp;*</TT>,
but
<TT>s4</TT> is declared as a <TT>char</TT>,
which is probably not the intention.
(See also question <a href="faqcatd3c2.html?sec=decl#charstarws">1.5</a>.)
</p><p><TT>#define</TT>s do have the advantage that <TT>#ifdef</TT> works on them
(see also question <a href="faqcat204f.html?sec=cpp#iftypedef">10.15</a>).
On the other hand,
<TT>typedef</TT>s

have the advantage that they obey scope rules
(that is, they can be declared local to a function or block).
</p><p>See also questions
<a href="faqcatd3c2.html?sec=decl#pfitypedef">1.17</a>,
<a href="faqcat6b6b.html?sec=struct#enumvsdefine">2.22</a>,
<a href="faqcat7d4b.html?sec=ansi#typedefconst">11.11</a>,
and
<a href="faqcat744e.html?sec=varargs#funcptr">15.11</a>.
</p>


<p>References:

K&amp;R1 Sec. 6.9 p. 141
<br>
K&amp;R2 Sec. 6.7 pp. 146-7
<br>
CT&amp;P Sec. 6.4 pp. 83-4
<hr><hr><hr>
<a name="selfrefstruct">
<h1>
comp.lang.c FAQ list
<font color=blue>&middot;</font>
<a href="../../decl/selfrefstruct.html"><!-- qtag -->Question 1.14</a>
</h1>
<p>
<font face=Helvetica size=8 color=blue><b>Q:</b></font>

I can't seem to define a linked list
successfully.
I tried
<pre>
	typedef struct {
		char *item;
		NODEPTR next;
	} *NODEPTR;
</pre>
but the compiler gave me error messages.
Can't a structure in C contain a pointer to itself?

</p><p><hr>
<p>
<font face=Helvetica size=8 color=blue><b>A:</b></font>
Structures in C can certainly contain pointers to themselves; the
discussion and example in section 6.5 of K&amp;R

make this clear.
</p><p>The problem with
this example is



the typedef.


A typedef defines a new name for a type,
and in simpler cases
<a href="../../decl/immtypedef.html" rel=subdocument>[footnote]</a>
you can define a new structure type
and a typedef for it
at the same time,
but not in this case.
A typedef declaration can
not be used until it is defined,
and in the fragment above,
it is not yet
defined
at the point where
the <TT>next</TT> field is declared.
</p><p>To fix
this code,
first
give the structure a tag (e.g. ``<TT>struct&nbsp;node</TT>'').
Then,
declare the <TT>next</TT> field
as
a simple
<TT>struct&nbsp;node&nbsp;*</TT>,

or disentangle the typedef declaration from the structure definition,
or both.
One
corrected
version would be:
<pre>
	typedef struct node {
		char *item;
		struct node *next;
	} *NODEPTR;
</pre>
You could also precede the struct declaration

with
the typedef,
in which case you could use the <TT>NODEPTR</TT> typedef when declaring
the <TT>next</TT> field,
after all:
<pre>
	typedef struct node *NODEPTR;

	struct node {
		char *item;
		NODEPTR next;
	};
</pre>
(In this case,
you declare a new tyedef name involving <TT>struct&nbsp;node</TT>
even though <TT>struct&nbsp;node</TT>
has not been
completely
defined
yet;

this you're allowed to do.<a href="../../decl/jst1.html" rel=subdocument>[footnote]</a>
)
</p><p>Finally,
here is a rearrangement incorporating both suggestions:
<pre>
	struct node {
		char *item;
		struct node *next;
	};

	typedef struct node *NODEPTR;
</pre>
</p><p>(It's a matter of style which method to prefer;
see
section
<a href="faqcataae2.html?sec=style#index">17</a>.)
</p><p>See also questions
<a href="faqcatd3c2.html?sec=decl#mutrefstructs">1.15</a>
and
<a href="faqcat6b6b.html?sec=struct#typedef">2.1</a>.
</p>







<p>References:

K&amp;R1 Sec. 6.5 p. 101
<br>
K&amp;R2 Sec. 6.5 p. 139
<br>
ISO Sec. 6.5.2, Sec. 6.5.2.3
<br>
H&amp;S Sec. 5.6.1 pp. 132-3
<hr><hr><hr>
<a name="mutrefstructs">
<h1>
comp.lang.c FAQ list
<font color=blue>&middot;</font>
<a href="../../decl/mutrefstructs.html"><!-- qtag -->Question 1.15</a>
</h1>
<p>
<font face=Helvetica size=8 color=blue><b>Q:</b></font>
How can I define a pair of mutually referential structures?
I tried
<pre>
	typedef struct {
		int afield;
		BPTR bpointer;
	} *APTR;

	typedef struct {
		int bfield;
		APTR apointer;
	} *BPTR;
</pre>
but the compiler doesn't know about
<TT>BPTR</TT>
when it is used in
the first structure declaration.
</p><p><hr>
<p>
<font face=Helvetica size=8 color=blue><b>A:</b></font>
As in question <a href="faqcatd3c2.html?sec=decl#selfrefstruct">1.14</a>,
the problem lies not in
the structures or
the pointers but the typedefs.
First,
give the two structures tags,
and
define
the link pointers
without using typedefs:
<pre>
	struct a {
		int afield;
		struct b *bpointer;
	};

	struct b {
		int bfield;
		struct a *apointer;
	};
</pre>
The compiler can accept the field declaration <TT>struct&nbsp;b&nbsp;*bpointer</TT>
within <TT>struct&nbsp;a</TT>,
even though it has not yet heard of
<TT>struct&nbsp;b</TT>.
(<TT>struct&nbsp;b</TT> is
``incomplete''
at that point.)

Occasionally it is necessary to precede this couplet with the
empty declaration
<pre>
	struct b;
</pre>
to mask the declarations (if in an inner scope) from a different
<TT>struct&nbsp;b</TT> in an outer scope.
</p><p>After declaring the two structures using struct tags,
you can then declare the typedefs separately:
<pre>
	typedef struct a *APTR;
	typedef struct b *BPTR;
</pre>
</p><p>
Alternatively,

you can define the typedefs
before the struct definitions<a href="../../decl/jst2.html" rel=subdocument>[footnote]</a>
,
in which case you can use them when declaring the link pointer 
fields:
<pre>
	typedef struct a *APTR;
	typedef struct b *BPTR;

	struct a {
		int afield;
		BPTR bpointer;
	};

	struct b {
		int bfield;
		APTR apointer;
	};
</pre>
</p><p>See also question <a href="faqcatd3c2.html?sec=decl#selfrefstruct">1.14</a>.
</p>



<p>References:

K&amp;R2 Sec. 6.5 p. 140
<br>
ISO Sec. 6.5.2.3
<br>
H&amp;S Sec. 5.6.1 p. 132
<hr><hr><hr>
<a name="structtypdf">
<h1>
comp.lang.c FAQ list
<font color=blue>&middot;</font>
<a href="../../decl/structtypdf.html"><!-- qtag -->Question 1.16</a>
</h1>
<p>
<font face=Helvetica size=8 color=blue><b>Q:</b></font>
What's the difference between
these two declarations?
<pre>
	struct x1 { ... };
	typedef struct { ... } x2;
</pre>
</p>
<p><hr>
<p>
<font face=Helvetica size=8 color=blue><b>A:</b></font>
See question <a href="faqcat6b6b.html?sec=struct#typedef">2.1</a>.
<hr><hr><hr>
<a name="pfitypedef">
<h1>
comp.lang.c FAQ list
<font color=blue>&middot;</font>
<a href="../../decl/pfitypedef.html"><!-- qtag -->Question 1.17</a>
</h1>
<p>
<font face=Helvetica size=8 color=blue><b>Q:</b></font>
What does
<pre>
typedef int (*funcptr)();</pre>

mean?
</p><p><hr>
<p>
<font face=Helvetica size=8 color=blue><b>A:</b></font>
It defines a typedef, <TT>funcptr</TT>, for a pointer to a
function
(taking unspecified arguments)
returning an <TT>int</TT>.
It can be used to
declare
one or more
pointers to functions:
<pre>
	funcptr pf1, pf2;
</pre>
which is equivalent to the more verbose,
and perhaps harder to understand
<pre>
	int (*pf1)(), (*pf2)();
</pre>
See also questions
<a href="faqcatd3c2.html?sec=decl#cdecl1">1.21</a>,

<a href="faqcatabdc.html?sec=ptrs#funccall">4.12</a>,
and
<a href="faqcat744e.html?sec=varargs#funcptr">15.11</a>.
</p>

<p>References:

K&amp;R1 Sec. 6.9 p. 141
<br>
K&amp;R2 Sec. 6.7 p. 147
<hr><hr><hr>
<a name="typdfcnst">
<h1>
comp.lang.c FAQ list
<font color=blue>&middot;</font>
<a href="../../decl/typdfcnst.html"><!-- qtag -->Question 1.18</a>
</h1>
<p>
<font face=Helvetica size=8 color=blue><b>Q:</b></font>
I've got
the declarations
<pre>
	typedef char *charp;
	const charp p;
</pre>
Why is <TT>p</TT> turning out <TT>const</TT>,
instead of the characters pointed to?
</p>
<p><hr>
<p>
<font face=Helvetica size=8 color=blue><b>A:</b></font>
See question <a href="faqcat7d4b.html?sec=ansi#typedefconst">11.11</a>.
<hr><hr><hr>
<a name="constasconst">
<h1>
comp.lang.c FAQ list
<font color=blue>&middot;</font>
<a href="../../decl/constasconst.html"><!-- qtag -->Question 1.19</a>
</h1>
<p>
<font face=Helvetica size=8 color=blue><b>Q:</b></font>
I don't understand why I can't
use <TT>const</TT> values in initializers and array
dimensions,
as in
<pre>
	const int n = 5;
	int a[n];
</pre>
</p>
<p><hr>
<p>
<font face=Helvetica size=8 color=blue><b>A:</b></font>
See question <a href="faqcat7d4b.html?sec=ansi#constasconst">11.8</a>.
<hr><hr><hr>
<a name="constptrconst">
<h1>
comp.lang.c FAQ list
<font color=blue>&middot;</font>
<a href="../../decl/constptrconst.html"><!-- qtag -->Question 1.20</a>
</h1>
<p>
<font face=Helvetica size=8 color=blue><b>Q:</b></font>
What's the difference between
<TT>const&nbsp;char&nbsp;*p</TT>,
<TT>char&nbsp;const&nbsp;*p</TT>,
and <TT>char&nbsp;*&nbsp;const&nbsp;p</TT>?
</p>
<p><hr>
<p>
<font face=Helvetica size=8 color=blue><b>A:</b></font>
See questions
<a href="faqcat7d4b.html?sec=ansi#constptrconst">11.9</a>
and

<a href="faqcatd3c2.html?sec=decl#cdecl1">1.21</a>.
<hr><hr><hr>
<a name="constparm">
<h1>
comp.lang.c FAQ list
<font color=blue>&middot;</font>
<a href="../../decl/constparm.html"><!-- qtag -->Question 1.20b</a>
</h1>
<p>
<font face=Helvetica size=8 color=blue><b>Q:</b></font>
What does it mean for a function parameter to be <TT>const</TT>?
What do the two <TT>const</TT>'s in
<pre>
	int f(const * const p)
</pre>
mean?
</p>



<p><hr>
<p>
<font face=Helvetica size=8 color=blue><b>A:</b></font>
In
<pre>
	int f(const * const p)
</pre>
the first of the two <TT>const</TT>'s
is perfectly appropriate and quite useful; many
functions declare parameters which are pointers to const data,
and doing so documents (and tends to enforce) the function's
promise that it won't modify the pointed-to data in the caller.
The second <TT>const</TT>, on the other hand, is almost useless; all it
says is that the function won't alter its own copy of the
pointer, even though it wouldn't cause the caller <em>or</em> the
function any problems if it did, nor is this anything the caller
should care about in any case.
The situation is the same as if a
function declared an ordinary (non-pointer) parameter as const:
<pre>
	int f2(const int x)
</pre>
This says that nowhere in the body of <TT>f2()</TT> will the function
assign a different value to <TT>x</TT>.
(Compilers should try to enforce this promise, too.)
But assigning a
different value to <TT>x</TT> wouldn't affect the value that the caller
had passed (because C always uses call-by-value), so it's an
unimportant guarantee, and in fact a pretty useless one, because
what does the function gain by promising (to itself, since it's
the only one that could care) whether it will or won't be
modifying in the passed-in copy of the value?
<hr><hr><hr>
<a name="cdecl1">
<h1>
comp.lang.c FAQ list
<font color=blue>&middot;</font>
<a href="../../decl/cdecl1.html"><!-- qtag -->Question 1.21</a>
</h1>
<p>
<font face=Helvetica size=8 color=blue><b>Q:</b></font>
How do I
construct
declarations of complicated types such as
``array of N pointers to functions returning
pointers to functions returning pointers
to <TT>char</TT>'',
or figure out what similarly complicated declarations mean?
</p><p><hr>
<p>
<font face=Helvetica size=8 color=blue><b>A:</b></font>
The first part of
this
question can be answered in
at least three ways:
<OL><li><TT>char *(*(*a[N])())();
</TT><li>Build the declaration up
incrementally,
using
typedefs:
<pre>
	typedef char *pc;	/* pointer to char */
	typedef pc fpc();	/* function returning pointer to char */
	typedef fpc *pfpc;	/* pointer to above */