Are static functions in C language really invisible?

Question

I was told that a function defined as static in one .c file is not accessible from other files. But in the following program, I can access the static void show() function from another file. Is my understanding of static functions in C wrong?

a.h (first file):

static void show()
{
printf("I am in static show function in a.c");
}

b.c (another file):

#include"a.h"
void main()
{
show();
}

Answer 1

Remember that #includes work by copy-and-pasting the content of the included file. So in your example, after the #include has been processed, you get this:

static void show()
{
printf("I am in static show function in a.c");
}

void main()
{
show();
}

So clearly main can see show.¹

The solution is to not #include .c files. In general, you should only #include header (.h) files. Your static functions shouldn't be declared or defined in the header file, so main will not be able to see it.

---

_{1. However, you now actually have two definitions of the show function, one in a.c and one in b.c. For static functions, this isn't a problem, but for non-static functions you would get a linker error.}

Answer 2

static keyword changes the linkage specification to Internal Linkage.
A function marked as static will only be visible in that Translation Unit(TU).

Perhaps, You have same named symbols available in that particular TU, where you access the function. The how part of it can be only answered after you show us the code.

EDIT:
When you define a static function in header file, A copy of the same function gets created in every Translation Unit where you include it.Each instance of such a function is treated as a separate function(address of each function is different) and each instance of these functions have their own copies of static local variables & string literals.

Clearly, this will work but this might as well increase the size of your generated binary.

Answer 3

The other answers are correct, but it's not quite accurate to say that the static function is not accessible from another file. It is possible to access the function through a function pointer. It would be more accurate to say that the name of the function is not accessible in another translation unit.

Remember that converting C source code to an executable program consists of conceptual stages, including:

1. preprocessing (in which #include directives are replaced with the contents of the included file
2. compilation (which processes one translation unit at a time)
3. linking (in which the translation units are put together into the final program)

Suppose we have three files. foo.h:

typedef void (*void_function_p)(void);

extern void_function_p foo(void);

foo.c:

#include "foo.h"
#include <stdio.h>

static void baz(void) {
    printf("worked!\n");
}

void_function_p foo(void) {
    return baz;
}

bar.c:

#include "foo.h"
#include <stdio.h>

int main(void) {
    (*foo())();
    return 0;
}

This program compiles and prints "worked!" when it runs.

There are two translation units here. One is the code in the preprocessed foo.c (which, because of how #include works also includes the code in foo.h and stdio.h). The other is the code in the preprocessed bar.c (which, again, has its own copy of the code in foo.h and stdio.h).

By having the function foo return a pointer to the static function baz, we are able to call baz from the main function.

Now, consider what happens if we modify main to look like this:

int main(void) {
    (*foo())();
    baz();
    return 0;
}

This code will result in a linker error because the name baz in this translation unit cannot be linked to the definition of baz in the other translation unit.

This is the first advantage of static functions: another programmer cannot accidentally access our baz function from another translation unit.

Now, consider what happens if we modify bar.c to look like this:

#include "foo.h"
#include <stdio.h>

static void baz(void) {
        printf("still works!");
}

int main() {
        (*foo())();
        baz();
        return 0;
}

This code will compile, and print "worked!" followed by "still works!"

This is the second advantage of static functions: we've defined two functions (in different translation units) with the same name.

If you try to put both static definitions in the same translation unit, you will get a compiler error about defining baz twice.

As a final note, if you take the program as it now stands and remove all the statics, it will result in a linker error because baz has been defined twice (with external linkage), which is not permitted.