Some questions about C

[Haskell Prelude]

Hello Friends -

Can anyone answer these C questions?

1. What is the effect of making an internal (local) variable static?
2. What is the effect of making an external (non-local) variable static?
3. What, possibly including garbage, is output by the following code?

int a = 10;
int b = 12;

ftn2(int a) {
int c = 13;
printf("%d\n", a+b);
return ++a;
}

ftn(int b) {
b = a;
printf("%d\n", b);
return ftn2(a);
}

void main()
{
int x = ftn(b);
printf("%d\n", x);
}

Thanks to all!

[pete]

pete wrote:

>
CBFalconer wrote:

James Kuyper wrote:

CBFalconer wrote:
...
>>2. What is the effect of making an external (non-local) variable

<<< static?

>>
>Pure foolishness, if non-local means file scope. static here
>prevents exporting the variable.
>
Why is that foolishness? I've used precisely that technique for
encapsulation. File scope variables are something to avoided, in
general. However, when they are justified, in some cases the
dangers of using them can be reduced by declaring them static.
This requires that all functions which refer to the static file
scope variable be defined in the same translation unit, which may
be quite feasible if the number of such functions is small.

Because if it is external it can't be static, or it won't be found.

/* BEGIN new.c */

#include <stdio.h>

static char string[] = "What do you mean?";

int main(void)
{
puts(string);
return 0;
}

/* END new.c */

By "external variable",
I mean an object that was declared in an "external declaration"
and defined in an "external definition",
rather than a variable with external linkage.

I interpreted OP's comment "(non-local)",
to mean that "file scope"
was the definition being used for "external".

N869
6.9 External definitions
Syntax
[#1]
translation-unit:
external-declaration
translation-unit external-declaration
external-declaration:
function-definition
declaration
Constraints
[#2] The storage-class specifiers auto and register shall
not appear in the declaration specifiers in an external
declaration.
[#3] There shall be no more than one external definition for
each identifier declared with internal linkage in a
translation unit. Moreover, if an identifier declared with
internal linkage is used in an expression (other than as a
part of the operand of a sizeof operator), there shall be
exactly one external definition for the identifier in the
translation unit.
Semantics
[#4] As discussed in 5.1.1.1, the unit of program text after
preprocessing is a translation unit, which consists of a
sequence of external declarations. These are described as
``external'' because they appear outside any function (and
hence have file scope). As discussed in 6.7, a declaration
that also causes storage to be reserved for an object or a
function named by the identifier is a definition.
[#5] An external definition is an external declaration that
is also a definition of a function or an object. If an
identifier declared with external linkage is used in an
expression (other than as part of the operand of a sizeof
operator), somewhere in the entire program there shall be
exactly one external definition for the identifier;
otherwise, there shall be no more than one.

--
pete

[James Kuyper]

CBFalconer wrote:

James Kuyper wrote:

>CBFalconer wrote:
...

>>>2. What is the effect of making an external (non-local) variable

<<< static?

>>Pure foolishness, if non-local means file scope. static here
prevents exporting the variable.

Why is that foolishness? I've used precisely that technique for
encapsulatio n. File scope variables are something to avoided, in
general. However, when they are justified, in some cases the
dangers of using them can be reduced by declaring them static.
This requires that all functions which refer to the static file
scope variable be defined in the same translation unit, which may
be quite feasible if the number of such functions is small.

Because if it is external it can't be static, or it won't be found.

If the phrase 'external ... variable' was meant to be a short form for
"variable with external linkage", then the question is meaningless, for
precisely that reason.

The questions were clearly not written in strictly correct standardese.
Therefore, some interpretation is required. My interpretation was that
by "external (non-local)" he meant file scope. My interpretation has the
advantage that it makes the question meaningful; but it might not be
correct.

[CBFalconer]

pete wrote:

CBFalconer wrote:

.... snip ...

>

>Because if it is external it can't be static, or it won't be found.

/* BEGIN new.c */
#include <stdio.h>
static char string[] = "What do you mean?";

int main(void) {
puts(string);
return 0;
}
/* END new.c */

Note the total absence of the 'extern' keyword.

--
Chuck F (cbfalconer at maineline dot net)
<http://cbfalconer.home .att.net>
Try the download section.

--
Posted via a free Usenet account from http://www.teranews.com

[Richard Heathfield]

CBFalconer said:

pete wrote:

>CBFalconer wrote:

... snip ...

>>

>>Because if it is external it can't be static, or it won't be found.

/* BEGIN new.c */
#include <stdio.h>
static char string[] = "What do you mean?";

int main(void) {
puts(string);
return 0;
}
/* END new.c */

Note the total absence of the 'extern' keyword.

Note the absence of the word 'extern' from the original question, too.

Quoth the Standard: "If the declaration of an identifier for an object has
file scope and an initializer, the declaration is an external definition
for the identifier." Statically qualified declarations are not excluded
from this.

--
Richard Heathfield <http://www.cpax.org.uk >
Email: -http://www. +rjh@
Google users: <http://www.cpax.org.uk/prg/writings/googly.php>
"Usenet is a strange place" - dmr 29 July 1999

[Jack Klein]

On Sun, 18 Nov 2007 02:04:48 -0500, CBFalconer <cb********@yah oo.com>
wrote in comp.lang.c:

Haskell Prelude wrote:

1. What is the effect of making an internal (local) variable static?

If by local you mean scoped within a function, then it becomes a
non-auto variable and preserves its value between function calls.

2. What is the effect of making an external (non-local) variable static?

Pure foolishness, if non-local means file scope. static here
prevents exporting the variable.

Actually, defining a file scope object with the static keyword merely
changes the linkage of the identifier from external to internal. It
does nothing at all to the "variable", actually object, itself.

--
Jack Klein
Home: http://JK-Technology.Com
FAQs for
comp.lang.c http://c-faq.com/
comp.lang.c++ http://www.parashift.com/c++-faq-lite/
alt.comp.lang.l earn.c-c++
http://www.club.cc.cmu.edu/~ajo/docs/FAQ-acllc.html

[Jack Klein]

On Sun, 18 Nov 2007 09:44:18 -0500, CBFalconer <cb********@yah oo.com>
wrote in comp.lang.c:

James Kuyper wrote:

CBFalconer wrote:
...

>2. What is the effect of making an external (non-local) variable

<<< static?

>
Pure foolishness, if non-local means file scope. static here
prevents exporting the variable.

Why is that foolishness? I've used precisely that technique for
encapsulation. File scope variables are something to avoided, in
general. However, when they are justified, in some cases the
dangers of using them can be reduced by declaring them static.
This requires that all functions which refer to the static file
scope variable be defined in the same translation unit, which may
be quite feasible if the number of such functions is small.

Because if it is external it can't be static, or it won't be found.

Your terminology is confused. The C standard defines any definition
at file scope as an external definition. Even if the definition uses
the static keyword. The fact that the static keyword changes the
linkage of the identifier from external to internal does not change
the fact that it is an external definition.

--
Jack Klein
Home: http://JK-Technology.Com
FAQs for
comp.lang.c http://c-faq.com/
comp.lang.c++ http://www.parashift.com/c++-faq-lite/
alt.comp.lang.l earn.c-c++
http://www.club.cc.cmu.edu/~ajo/docs/FAQ-acllc.html

[pete]

Richard Heathfield wrote:

>
CBFalconer said:

pete wrote:

CBFalconer wrote:

... snip ...

>
Because if it is external it can't be static,
or it won't be found.

/* BEGIN new.c */
#include <stdio.h>
static char string[] = "What do you mean?";

int main(void) {
puts(string);
return 0;
}
/* END new.c */

Note the total absence of the 'extern' keyword.

Note the absence of the word 'extern' from the original question, too.

Quoth the Standard:
"If the declaration of an identifier for an object has
file scope and an initializer,
the declaration is an external definition
for the identifier.
" Statically qualified declarations are not excluded from this.

OP was clear that by "external" he meant "(non-local)",
which CBFalconer properly understood to mean "file scope",
just slightly before becoming confused.

"2. What is the effect of making an external (non-local) variable
static?"


--
pete