What is a "static" function in C?
Solution 1
static
functions are functions that are only visible to other functions in the same file (more precisely the same translation unit).
EDIT: For those who thought, that the author of the questions meant a 'class method': As the question is tagged C
he means a plain old C function. For (C++/Java/...) class methods, static
means that this method can be called on the class itself, no instance of that class necessary.
Solution 2
There is a big difference between static functions in C and static member functions in C++. In C, a static function is not visible outside of its translation unit, which is the object file it is compiled into. In other words, making a function static limits its scope. You can think of a static function as being "private" to its *.c file (although that is not strictly correct).
In C++, "static" can also apply to member functions and data members of classes. A static data member is also called a "class variable", while a non-static data member is an "instance variable". This is Smalltalk terminology. This means that there is only one copy of a static data member shared by all objects of a class, while each object has its own copy of a non-static data member. So a static data member is essentially a global variable, that is a member of a class.
Non-static member functions can access all data members of the class: static and non-static. Static member functions can only operate on the static data members.
One way to think about this is that in C++ static data members and static member functions do not belong to any object, but to the entire class.
Solution 3
Minimal runnable multi-file scope example
Here I illustrate how static
affects the scope of function definitions across multiple files.
a.c
#include <stdio.h>
/* Undefined behavior: already defined in main.
* Binutils 2.24 gives an error and refuses to link.
* https://stackoverflow.com/questions/27667277/why-does-borland-compile-with-multiple-definitions-of-same-object-in-different-c
*/
/*void f() { puts("a f"); }*/
/* OK: only declared, not defined. Will use the one in main. */
void f(void);
/* OK: only visible to this file. */
static void sf() { puts("a sf"); }
void a() {
f();
sf();
}
main.c
#include <stdio.h>
void a(void);
void f() { puts("main f"); }
static void sf() { puts("main sf"); }
void m() {
f();
sf();
}
int main() {
m();
a();
return 0;
}
Compile and run:
gcc -c a.c -o a.o
gcc -c main.c -o main.o
gcc -o main main.o a.o
./main
Output:
main f
main sf
main f
a sf
Interpretation
- there are two separate functions
sf
, one for each file - there is a single shared function
f
As usual, the smaller the scope, the better, so always declare functions static
if you can.
In C programming, files are often used to represent "classes", and static
functions represent "private" methods of the class.
A common C pattern is to pass a this
struct around as the first "method" argument, which is basically what C++ does under the hood.
What standards say about it
C99 N1256 draft 6.7.1 "Storage-class specifiers" says that static
is a "storage-class specifier".
6.2.2/3 "Linkages of identifiers" says static
implies internal linkage
:
If the declaration of a file scope identifier for an object or a function contains the storage-class specifier static, the identifier has internal linkage.
and 6.2.2/2 says that internal linkage
behaves like in our example:
In the set of translation units and libraries that constitutes an entire program, each declaration of a particular identifier with external linkage denotes the same object or function. Within one translation unit, each declaration of an identifier with internal linkage denotes the same object or function.
where "translation unit" is a source file after preprocessing.
How GCC implements it for ELF (Linux)?
With the STB_LOCAL
binding.
If we compile:
int f() { return 0; }
static int sf() { return 0; }
and disassemble the symbol table with:
readelf -s main.o
the output contains:
Num: Value Size Type Bind Vis Ndx Name
5: 000000000000000b 11 FUNC LOCAL DEFAULT 1 sf
9: 0000000000000000 11 FUNC GLOBAL DEFAULT 1 f
so the binding is the only significant difference between them. Value
is just their offset into the .bss
section, so we expect it to differ.
STB_LOCAL
is documented on the ELF spec at http://www.sco.com/developers/gabi/2003-12-17/ch4.symtab.html:
STB_LOCAL Local symbols are not visible outside the object file containing their definition. Local symbols of the same name may exist in multiple files without interfering with each other
which makes it a perfect choice to represent static
.
Functions without static are STB_GLOBAL
, and the spec says:
When the link editor combines several relocatable object files, it does not allow multiple definitions of STB_GLOBAL symbols with the same name.
which is coherent with the link errors on multiple non static definitions.
If we crank up the optimization with -O3
, the sf
symbol is removed entirely from the symbol table: it cannot be used from outside anyways. TODO why keep static functions on the symbol table at all when there is no optimization? Can they be used for anything?
See also
- Same for variables: https://stackoverflow.com/a/14339047/895245
-
extern
is the opposite ofstatic
, and functions are alreadyextern
by default: How do I use extern to share variables between source files?
C++ anonymous namespaces
In C++, you might want to use anonymous namespaces instead of static, which achieves a similar effect, but further hides type definitions: Unnamed/anonymous namespaces vs. static functions
Solution 4
The following is about plain C functions - in a C++ class the modifier 'static' has another meaning.
If you have just one file, this modifier makes absolutely no difference. The difference comes in bigger projects with multiple files:
In C, every "module" (a combination of sample.c and sample.h) is compiled independently and afterwards every of those compiled object files (sample.o) are linked together to an executable file by the linker.
Let's say you have several files that you include in your main file and two of them have a function that is only used internally for convenience called add(int a, b)
- the compiler would easily create object files for those two modules, but the linker will throw an error, because it finds two functions with the same name and it does not know which one it should use (even if there's nothing to link, because they aren't used somewhere else but in it's own file).
This is why you make this function, which is only used internal, a static function. In this case the compiler does not create the typical "you can link this thing"-flag for the linker, so that the linker does not see this function and will not generate an error.
Solution 5
static function definitions will mark this symbol as internal. So it will not be visible for linking from outside, but only to functions in the same compilation unit, usually the same file.
Slava V
Updated on April 19, 2022Comments
-
Slava V about 2 years
The question was about plain c functions, not c++
static
methods, as clarified in comments.I understand what a
static
variable is, but what is astatic
function?And why is it that if I declare a function, let's say
void print_matrix
, in let's saya.c
(WITHOUTa.h
) and include"a.c"
- I get"print_matrix@@....) already defined in a.obj"
, BUT if I declare it asstatic void print_matrix
then it compiles?UPDATE Just to clear things up - I know that including
.c
is bad, as many of you pointed out. I just do it to temporarily clear space inmain.c
until I have a better idea of how to group all those functions into proper.h
and.c
files. Just a temporary, quick solution. -
Slava V over 15 yearsActually I didn't tag it c++, some of admins probably did, but it was about C++, so what's the difference in C++?
-
Slava V over 15 yearsIt seems to me that you are talking about static "method", not "function"??
-
Chuck over 15 yearsC++ methods are often referred to as "member functions", so I agree that C++ introduces a little bit of ambiguity. It's not your fault — the language just uses the keyword for two different things.
-
Slava V over 15 yearsWell, I do it just to clear up some space TEMPORARILY in main.cpp until I decide how to organize the file into libraries along with proper .hpp's. Is there a better idea how to do this?
-
Dai Doan over 15 yearsThere are no "methods" in C++, just functions. The C++ standard doesn't ever mention "methods", just "functions".
-
Dai Doan over 15 yearsThe correct terminology in C++ is member function, not method. There are no "methods" in C++ legalese. Method is a general OO term. C++ implements them via member functions.
-
Johannes Weiss over 15 yearsThats just fine, but don't you agree that it way clear Slava meant a normal function?
-
Prasanth Kumar over 15 years@Johannes Yes, because otherwise the question body doesn't make any sense at all. However, the question title makes many people think about the most common use of "static" in functions in C++, which is in member functions (because member functions are far more common than nonmember ones).
-
Johannes Weiss over 15 yearsDaniel, yes. thats true. When I 'opened' the question I was thinking I'll explain class-static. Then I read the question and realized that I have to explain normal-function-static ;-). But remember: The question has be retagged by someone else to C++.
-
Lightness Races in Orbit over 13 yearsNo, he still means a C++ function. A C++ free function rather than a C++ member function.
-
Lightness Races in Orbit over 13 yearsC++ has file-static, too. No need to bring C into this.
-
Gerasimos R over 11 yearsIn C++, a static function is a static function. A static member function is a static member function, also known as a method. The fact that C does not have members does not mean that functions are "C".
-
Alexander Malakhov over 11 yearsis there any difference between global var and class static var (except namespace) ?
-
Pigsty over 11 yearsThe namespace is the main difference. The other difference is that you can make a static data member private and thus only accessible from within the class' member functions. In other words, you have much more control over a static data member compared to a global variable.
-
sidgeon smythe over 9 years@Chuck: C++ terminology never uses the word "method"; that's Java terminology -- in C++ standard documents it is always called "member function" (see this answer or this glossary of C++ vs Java terms (e.g. C++ uses "data member" and Java uses "field", etc)).
-
YoTengoUnLCD over 8 yearsCould someone explain why thinking of a static function as private to its .c file not strictly correct? What's left to say?
-
Pigsty over 8 years@YoTengoUnLCD, what if your .c file #include's another .c file? By the way, this would make a good SO question in its own right. You should ask it.
-
M.M over 8 yearsTo clarify this answer a bit: the name of the function is only visible to other parts of the same translation unit, below the first declaration of that name. The function may be called from other units (and earlier parts of the same unit) via other means, e.g. a function pointer.
-
M.M over 8 yearsnote:
void f() { puts("sf"); }
(i.e. two definitions off()
) causes undefined behaviour with no diagnostic required. It's a quality-of-linker issue to actually see an error message. -
Puddle over 5 years@BrianNeal a method is a class function. if it's not static it implicitly takes in the instance of the object (this), so that you can access the members. and the compiler implicitly refers to the members without using this-> unless you made a local variable in that method. i think you mean C since that doesn't even have classes.
-
Dai Doan over 5 years@Puddle I know what you are saying but in the C++ standard there is no definition of a "method". C++ only has functions, of various kinds. "Method" is a general OO term and is used in other languages and informally in C++. A method is formally known as a "member function" in C++.
-
TomSawyer about 4 yearswhy if i include that file, i can access to that function. so the static is useless now? calling function without include can cause warning:
implicit declaration of function * is invalid in C99
-
DylanYoung about 4 yearsIf you include the file, then it's declared in the current file and so you can access it. Read up on the preprocessor: includes are not imports.
-
RobertS supports Monica Cellio about 4 yearsThis is not true. The explanation of your second paragraph refers to "static member functions" of a class, not "static functions". In C++, a function qualified with
static
has file-scope, too, like it is in C. -
Naasif over 3 years@JohannesWeiss Mr. Johannes Weiss I have got something to say. Does static function act like a static variable? I mean Does static function stay inside the scope?