visibility of variable

[rahul8143]

hello,
To limit scope of a variable in a single file that is part of a
large project that have several C files we use static variable
right?then to limit any variable to function scope it should be
declared as auto or anything else?

[Julienne Walker]

> To limit scope of a variable in a single file that is part of a

large project that have several C files we use static variable
right?
Right.
then to limit any variable to function scope it should be
declared as auto or anything else?

auto is the default for local variables, you don't need to do anything
special if you want a variable to be local to a function, just declare
it inside the function.

[Ben Pfaff]

ra*******@gmail.com writes:

To limit scope of a variable in a single file that is part of a
large project that have several C files we use static variable
right?then to limit any variable to function scope it should be
declared as auto or anything else?

It seems that you are confusing scope and linkage. Any variable
declared outside a function has file scope, regardless of whether
it is declared with `static' or not. However, `static' gives the
variable internal linkage, which means that it will not be linked
against file-scope identifiers in other translation units.

Variables declared inside a function have block scope, not
function scope. (Only labels have function scope.) When they
are declared without a storage class specifier, or with any
storage class specifier other than `extern', they have no
linkage.
--
"It wouldn't be a new C standard if it didn't give a
new meaning to the word `static'."
--Peter Seebach on C99

[Emmanuel Delahaye]

ra*******@gmail.com wrote on 26/09/05 :

To limit scope of a variable in a single file that is part of a
large project that have several C files we use static variable
right?then to limit any variable to function scope it should be
declared as auto or anything else?

There is no 'function scope'. There is 'block scope'. A variable
defined in a block has the block scope. If it has the 'static'
qualifier, it becomes persistent.

But these methods are not encouraged, specially for large project.
Better to work with 'contexts', where data are defined in a structure,
and where the code is designed to process the data.

It's the first step to Object Oriented Programming, that is a Good
Thing.

Next step is 'ADT' (Abstract Data Types). Google is your friend.

--
Emmanuel
The C-FAQ: http://www.eskimo.com/~scs/C-faq/faq.html
The C-library: http://www.dinkumware.com/refxc.html

"There are 10 types of people in the world today;
those that understand binary, and those that dont."

[Michael Mair]

Emmanuel Delahaye wrote:

ra*******@gmail.com wrote on 26/09/05 :

To limit scope of a variable in a single file that is part of a
large project that have several C files we use static variable
right?then to limit any variable to function scope it should be
declared as auto or anything else?
There is no 'function scope'.

There _is_ function scope.
Function scope is what labels are visible in.
There is 'block scope'. A variable defined
in a block has the block scope. If it has the 'static' qualifier, it
becomes persistent.

Right.
Cheers
Michael
--
E-Mail: Mine is an /at/ gmx /dot/ de address.

[Emmanuel Delahaye]

Michael Mair wrote on 26/09/05 :

Emmanuel Delahaye wrote:

ra*******@gmail.com wrote on 26/09/05 :

To limit scope of a variable in a single file that is part of a
large project that have several C files we use static variable
right?then to limit any variable to function scope it should be
declared as auto or anything else?

There is no 'function scope'.

There _is_ function scope.
Function scope is what labels are visible in.

There is 'block scope'. A variable defined in a block has the block scope.
If it has the 'static' qualifier, it becomes persistent.

Right.

Cheers
Michael

labels ? goto ? Sorry, I don't code in assembly nor in BASIC anymore
;-)
--
Emmanuel
The C-FAQ: http://www.eskimo.com/~scs/C-faq/faq.html
The C-library: http://www.dinkumware.com/refxc.html

I once asked an expert COBOL programmer, how to
declare local variables in COBOL, the reply was:
"what is a local variable?"

[Eric Sosman]

Emmanuel Delahaye wrote On 09/26/05 15:33,:

Michael Mair wrote on 26/09/05 :

Emmanuel Delahaye wrote:

ra*******@gmail.com wrote on 26/09/05 :
To limit scope of a variable in a single file that is part of a
large project that have several C files we use static variable
right?then to limit any variable to function scope it should be
declared as auto or anything else?

There is no 'function scope'.

There _is_ function scope.
Function scope is what labels are visible in.

There is 'block scope'. A variable defined in a block has the block scope.
If it has the 'static' qualifier, it becomes persistent.

Right.

Cheers
Michael

labels ? goto ? Sorry, I don't code in assembly nor in BASIC anymore
;-)

Do you write functions with non-empty argument lists?

--
Er*********@sun.com

[Emmanuel Delahaye]

Eric Sosman wrote on 26/09/05 :

labels ? goto ? Sorry, I don't code in assembly nor in BASIC anymore
;-)

Do you write functions with non-empty argument lists?

Yes, I do.

--
Emmanuel
The C-FAQ: http://www.eskimo.com/~scs/C-faq/faq.html
The C-library: http://www.dinkumware.com/refxc.html

I once asked an expert COBOL programmer, how to
declare local variables in COBOL, the reply was:
"what is a local variable?"

[Ben Pfaff]

Eric Sosman <er*********@sun.com> writes:

Emmanuel Delahaye wrote On 09/26/05 15:33,:

Michael Mair wrote on 26/09/05 :

Emmanuel Delahaye wrote:

There is no 'function scope'.

There _is_ function scope.
Function scope is what labels are visible in.

There is 'block scope'. A variable defined in a block has the block scope.
If it has the 'static' qualifier, it becomes persistent.

labels ? goto ? Sorry, I don't code in assembly nor in BASIC anymore
;-)

Do you write functions with non-empty argument lists?

Irrelevant. "A label name is the only kind of identifier that
has function scope." (C99 6.2.1)

You are thinking of function prototype scope.
--
"Some people *are* arrogant, and others read the FAQ."
--Chris Dollin

[pemo]

<ra*******@gmail.com> wrote in message
news:11**********************@g14g2000cwa.googlegr oups.com...

hello,
To limit scope of a variable in a single file that is part of a
large project that have several C files we use static variable
right?then to limit any variable to function scope it should be
declared as auto or anything else?

Related - is it bad form to actually use 'auto' - is being explicit best?

[Keith Thompson]

"pemo" <us************@gmail.com> writes:

<ra*******@gmail.com> wrote in message
news:11**********************@g14g2000cwa.googlegr oups.com...

hello,
To limit scope of a variable in a single file that is part of a
large project that have several C files we use static variable
right?then to limit any variable to function scope it should be
declared as auto or anything else?

Related - is it bad form to actually use 'auto' - is being explicit best?

There's no reason to use the "auto" keyword. It was useful in early
versions of C, where a variable declaration didn't require a type name
(defaulting to int), so "auto x;" would declare x as an int. In
modern C, the type name is required, so the "auto" keyword is
unnecessary.

--
Keith Thompson (The_Other_Keith) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[pemo]

"Keith Thompson" <ks***@mib.org> wrote in message
news:ln************@nuthaus.mib.org...

There's no reason to use the "auto" keyword. It was useful in early
versions of C, where a variable declaration didn't require a type name
(defaulting to int), so "auto x;" would declare x as an int. In
modern C, the type name is required, so the "auto" keyword is
unnecessary.

I realised that Keith, but I was wondering whether it'd be laughed at - if
one actually *used* auto

auto int n = 0;

I believe in being as explicit as is reasonable - so I was wondering what
others thought of this notion.

[Christopher Benson-Manica]

pemo <us************@gmail.com> wrote:

I realised that Keith, but I was wondering whether it'd be laughed at - if
one actually *used* auto
I don't know if one would be laughed at, but one's understanding of C
might well be called into question. A reviewer might wonder with good
reason what someone who wrote
auto int n = 0;
expected

int n=0;

to do.
I believe in being as explicit as is reasonable

It's a common and noble goal. The keyword "auto" has become
superfluous to the extent that using it obfuscates more than it
reveals. A student coming from a poorer C background might be unaware
of its existence.

--
Christopher Benson-Manica | I *should* know what I'm talking about - if I
ataru(at)cyberspace.org | don't, I need to know. Flames welcome.

[Flash Gordon]

pemo wrote:

"Keith Thompson" <ks***@mib.org> wrote in message
news:ln************@nuthaus.mib.org...

There's no reason to use the "auto" keyword. It was useful in early

<snip>
I realised that Keith, but I was wondering whether it'd be laughed at - if
one actually *used* auto

auto int n = 0;

I believe in being as explicit as is reasonable - so I was wondering what
others thought of this notion.

Personally, if I saw it at a review I would tell you to delete it. I
might also ask you what you were smoking when you put it in since no one
else does.

To me, the natural assumption with any language is that the scope of any
declared item will be the scope at which it is defined unless there is
something explicit overriding it. So why would one even consider
specifying that?

Actually, I would prefer it if things defaulted to not having external
linkage as well, but that is not how the language was defined.
--
Flash Gordon
Living in interesting times.
Although my email address says spam, it is real and I read it.

[Keith Thompson]

"pemo" <us************@gmail.com> writes:

"Keith Thompson" <ks***@mib.org> wrote in message
news:ln************@nuthaus.mib.org...

There's no reason to use the "auto" keyword. It was useful in early
versions of C, where a variable declaration didn't require a type name
(defaulting to int), so "auto x;" would declare x as an int. In
modern C, the type name is required, so the "auto" keyword is
unnecessary.
I realised that Keith, but I was wondering whether it'd be laughed at - if
one actually *used* auto

auto int n = 0;

Yes, you would be laughed at. I'm barely able to contain my giggles.
I believe in being as explicit as is reasonable - so I was wondering what
others thought of this notion.

In this particular case, that's more explicit than is reasonable, even
more so than

(void)printf("Hello, world\n");

--
Keith Thompson (The_Other_Keith) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.