static in function definition

[Ravi]

What is the difference between following function definitions:

static int f1()
{
/* code here */
}

and

int f1()
{
/* code here */
}

[Malcolm McLean]

"Ravi" <ra*********@gmail.comwrote in message
news:11**********************@m37g2000prh.googlegr oups.com...

What is the difference between following function definitions:

static int f1()
{
/* code here */
}

and

int f1()
{
/* code here */
}

The function declared static can only be called from another function within
the same file. This is very useful in complex projects, because it
simplifies the connections between modules.

--
Free games and programming goodies.
http://www.personal.leeds.ac.uk/~bgy1mm

[Flash Gordon]

Malcolm McLean wrote, On 27/08/07 21:57:

>
"Ravi" <ra*********@gmail.comwrote in message
news:11**********************@m37g2000prh.googlegr oups.com...

>What is the difference between following function definitions:

static int f1()
{
/* code here */
}

and

int f1()
{
/* code here */
}

The function declared static can only be called from another function
within the same file.

Incorrect. If can only be called *directly* from within the same
translation unit. Function pointers can and do get passed around
allowing functions declared static to be called from other translation
units.

This is very useful in complex projects, because
it simplifies the connections between modules.

True.
--
Flash Gordon

[Keith Thompson]

"Malcolm McLean" <re*******@btinternet.comwrites:

"Ravi" <ra*********@gmail.comwrote in message
news:11**********************@m37g2000prh.googlegr oups.com...

>What is the difference between following function definitions:
static int f1()
{
/* code here */
}

and

int f1()
{
/* code here */
}

The function declared static can only be called from another function
within the same file. This is very useful in complex projects, because
it simplifies the connections between modules.

Actually, it means that the name is only visible within the same
translation unit (which, with #include directives, could consiste of
multiple files). If you take the address of f1, you can call it
indirectly from anywhere.

In most cases, you wouldn't want to do this; if you want to call it
from another translation unit, you don't make it static. But I can
think of cases where you'd want to be able to call a function
indirectly without making its name directly visible.

--
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."
-- Antony Jay and Jonathan Lynn, "Yes Minister"

[Chris Thomasson]

"Keith Thompson" <ks***@mib.orgwrote in message
news:ln************@nuthaus.mib.org...
[...]

In most cases, you wouldn't want to do this; if you want to call it
from another translation unit, you don't make it static. But I can
think of cases where you'd want to be able to call a function
indirectly without making its name directly visible.

[...]

Here is an example of using a table of pointers to "private" static
functions in a translation unit for use as a vtable in a minimalist
object-oriented C technique:

http://groups.google.com/group/comp....106926ba5db19f

So, IMHO, there are very legitimate reasons to pass function pointers to
static functions.

[CBFalconer]

Ravi wrote:

>
What is the difference between following function definitions:

static int f1() {
/* code here */
}

and

int f1() {
/* code here */
}

The static function can only be called by code within the same
file, or code that has been passed a functional pointer to f1. The
name does not escape the particular source file involved. The
non-static name is visibile in all files at link time, and can
cause multi-defined errors, or peacefully link up as designed.

--
Chuck F (cbfalconer at maineline dot net)
Available for consulting/temporary embedded and systems.
<http://cbfalconer.home.att.net>

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

[karthikbalaguru]

Keith Thompson wrote:

"Malcolm McLean" <re*******@btinternet.comwrites:

"Ravi" <ra*********@gmail.comwrote in message
news:11**********************@m37g2000prh.googlegr oups.com...

What is the difference between following function definitions:
static int f1()
{
/* code here */
}

and

int f1()
{
/* code here */
}

The function declared static can only be called from another function
within the same file. This is very useful in complex projects, because
it simplifies the connections between modules.

It plays a great role in terms of scope of the function between
files .
It hides the name of this function from the other files so they cannot
use/call it.
But, there are ways to indirectly overcome that 'static' effect.
That is, Pointers to this function (Function pointers) can nullify the
static and make it accessible
across all the files.

>
Actually, it means that the name is only visible within the same
translation unit (which, with #include directives, could consiste of
multiple files). If you take the address of f1, you can call it
indirectly from anywhere.

Yeah, using the address, we can call it from anywhere.

Karthik Balaguru