If function declaration is not in header file, is static keyword necessary?

Question

If a function declaration isn't in a header file (.h), but is instead only in a source file (.c), why would you need to use the static keyword? Surely, if you only declare it in a .c file, it isn't seen by other files, as you're not supposed to #include .c files, right?

I have already read quite a few questions and answers about this (eg. here and here), but can't quite get my head around it.

In / not in a header does not affect accessibility, just visibility. When you declare a function `static`, the linker will not allow the function to satisfy the linkage needs of some other module. If you leave the keyword out, and in another module you declare the function (the same way you might in a header), you can link to it. — mah, Jul 01 '14 at 13:02
Right, so I'm guessing that in small projects (I'm a beginner!) this is unlikely to happen, as you'd know what all your functions are called and where you declared them, but in a bigger project you might declare a function with the same name twice…? — Bob Broadley, Jul 01 '14 at 13:07
Basically, that is to avoid namespace clashes. Familiarize yourself to use `static` everywhere you don't really need global visibility, otherwise you might end up defining the same name in different compilation units for different purposes. The linker - which just sees the name - will assume it's the same symbol and you might wonder about strange values... — mfro, Jul 01 '14 at 13:09

Fred Foo · Accepted Answer · 2014-07-01T14:25:11.907

8

What static does is make it impossible to declare and call a function in other modules, whether through a header file or not.

Recall that header file inclusion in C is just textual substitution:

// bar.c
#include "header.h"

int bar()
{
    return foo() + foo();
}

// header.h
int foo(void);

gets preprocessed to become

int foo(void);

int bar()
{
    return foo() + foo();
}

In fact, you can do away with header.h and just write bar.c this way in the first place. Similarly, the definition for foo does not need to include the header in either case; including it just adds a check that the definition and declaration for foo are consistent.

But if you were to change the implementation of foo to

static int foo()
{
    // whatever
    return 42;
}

then the declaration of foo would cease to work, in modules and in header files (since header files just get substituted into modules). Or actually, the declaration still "works", but it stops referring to your foo function and the linker will complain about that when you try to call foo.

The main reason to use static is to prevent linker clashes: even if foo and bar were in the same module and nothing outside the module called foo, if it weren't static, it would still clash with any other non-static function called foo. The second reason is optimization: when a function is static, the compiler knows exactly which parts of the program call it and with what arguments, so it can perform constant-folding, dead code elimination and/or inlining.

edited Jul 01 '14 at 14:25

answered Jul 01 '14 at 13:11

Fred Foo

355,277
75
744
836

Got it. So, in small projects you probably wouldn't get namespace clashes, but in anything bigger this *ensures* you wouldn't (right?) And secondly, it optimises the code (again not an issue for me at the moment) because it lets the compiler know that only one module requires access to that function (right??) – Bob Broadley Jul 01 '14 at 13:21
2

extern is implicit for all function prototypes – Steve Cox Jul 01 '14 at 13:59
1

@BobBroadley Even in small project it's advisable, when you're linking with libraries. Libraries should take care to use function names with a common prefix (like `bla_` for libbla), but they don't always and defensive programming is a good habit when writing C. – Fred Foo Jul 01 '14 at 14:16
@SteveCox: I didn't know that extern was explicit for prototypes; that makes a lot more sense now. I now see why static is needed "just in case". – Bob Broadley Jul 01 '14 at 14:23
@larsmans: right, that comment about libraries makes perfect sense. Even in a small project, I'm using a lot more than "just my code"! I knew I needed to use **static** to limit the scope of a function. The answers and comments here have helped me to understand why... – Bob Broadley Jul 01 '14 at 14:25

score 4 · Answer 2 · edited Jul 01 '14 at 13:29

The static keyword reduces the visibility of a function to the file scope. That means that you can't locally declare the function in other units and use it since the linker does not add it to the global symbol table. This also means that you can use the name in other units too (you may have a static void testOutput(); in every file, that is not possible if the static is omitted.)

As a rule of thumb you should keep the visibility of symbols as limited es possible. So if you do not need the routine outside (and it is not part of some interface) then keep it static.

barak manos · Answer 3 · 2014-07-01T13:32:57.323

It allows you to have functions with identical names in different source files, since the compiler adds an implicit prefix to the name of every static function (based on the name of the file in which the function is located), thus preventing multiple-definition linkage errors.
It helps whoever maintains the code to know that the function is not exposed as part of the interface, and is used only internally within the file (a non-static function can be used in other source files even if it's not declared in any header file, using the extern keyword).

If function declaration is not in header file, is static keyword necessary?

3 Answers3