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!

[Richard Heathfield]

Haskell Prelude said:

Hello Friends -

Can anyone answer these C questions?

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

Assuming that you mean an object defined at function scope or more locally
than that, adding the 'static' storage-class qualifier gives the object
static storage duration, which means that "the object exists and retains
its last-stored value throughout the execution of the entire program"
(3.1.2.4).

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

Assuming that you mean an object defined at file scope, adding the 'static'
storage-class qualifier has no effect on object lifetime since such an
object already has static storage duration by virtue of being at file
scope, but it does restrict visibility of the object to the translation
unit currently being translated.

3. What, possibly including garbage, is output by the following code?

The behaviour of "the following code" (snipped) is undefined for at least
two reasons.

--
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

[CBFalconer]

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.

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);
}

These functions would be fine if you just defined their return type
and #included <stdio.h>. The default int type is no longer valid
for C99. ftn2 prints the value of (a + 13) and returns (a + 1).
ftn ignores the input value of b, prints '10', then 23, and returns
11.

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

This is meaningless. main ALWAYS returns an int. You can always
return 0, or EXIT_FAILURE or EXIT_SUCCESS. The non-zero values
require #include stdlib.h. Lack of #include <stdio.hmakes all
the printf statements pure nonsense.

This homework like query would normally be ignored, but there are
too many built in errors to allow it to go uncriticized.

--
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

[Mark McIntyre]

Haskell Prelude wrote:

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?

These all sound like homework questions. You should really read your C
book and lecture notes.

>
void main()

Don't Do That.
main() returns an int in C.

[James Kuyper]

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.

[santosh]

In article <sl************ *******@nospam. com>, Haskell Prelude
<no*@avalid.ema il.comwrote on Sunday 18 Nov 2007 5:05 am:

Hello Friends -

Can anyone answer these C questions?

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

It retains it's value across execution into and out of it's scope.

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

The C term for "external" is file scope. And the effect is to reduce
it's visibility to the rest of the translation unit.

3. What, possibly including garbage, is output by the
following code?

int a = 10;
int b = 12;

ftn2(int a) {

Implicit return of int is obsolete. Declare 'ftn2' to explicitly return
a value or void.

int ftn2(int a) { ...

Furthermore 'ftn2's 'a' will "shadow" the filescope 'a'. It's not often
a good idea.

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

This will print the sum of 'ftn2's argument and the current value of 'b'
(at this point 12).

return ++a;

Returns a value one more than it's argument.

Note that 'c' is not used.

}

ftn(int b) {

Same comments about shadowing and implicit return as above.

b = a;

This references the filescope 'a'.

printf("%d\n", b);
return ftn2(a);
}

void main()

This is incorrect. In Standard C main must return an int. Also the empty
parenthesis signals to the compiler that main takes an unspecified
number and type of arguments, *not* no arguments, as in C++. To specify
the latter use the void keyword.

int main(void) { ...

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

Thanks to all!

Output will be:

10
22
11

[Richard]

CBFalconer <cb********@yah oo.comwrites:

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.

I fail to see any foolishness. What are you talking about?

>
This homework like query would normally be ignored, but there are
too many built in errors to allow it to go uncriticized.

*blink*

[Barry Schwarz]

On Sun, 18 Nov 2007 00:35:03 +0100 (CET), Haskell Prelude
<no*@avalid.ema il.comwrote:

>Hello Friends -

Can anyone answer these C questions?

You will find people much more willing to help if you make an effort
to do your homework first.
Remove del for email

[CBFalconer]

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.

--
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

[pete]

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 */
--
pete