Thread: static functions

Originally Posted by killme

Someone said to me once that when possible I should use static functions because it helps the compiler "in-line operations" (which I admittedly have no idea of the meaning). I was looking for documentation on this and found none and was hoping someone could clarify me on if/how that works.

I have never heard of this advice. In C++, the inline keyword is what I would use to hint to the compiler that I think a function is a good candidate to be inlined, i.e., instead of having a function call, the content of the function is placed at the point of the call. Note that this is only a hint so the compiler is free to ignore it.

Originally Posted by killme

I'm actually not seeing the application of a static function in general and would appreciate some help there as well.

In C, a static function would be used to make a function local to a translation unit. For example, if a function is implementation detail in a source file, you would declare it static so that say, there would be no conflict with an identically named function in another source file. In C++, this is superseded by the defining of functions within unnamed namespaces, so I do not use static non-member functions.

Originally Posted by killme

the class that I'm currently working at is something that only requires one object in the entire program and initially I was creating one in the main and passing by reference in the constructor to other classes that would need it.

Would it always be an error to have more than one such object and does the object need to be globally accessible? If so, then perhaps you should look into the singleton pattern. Otherwise, creating the object in the global main function and passing it to functions that need it is fine. You could disable the copy constructor and copy assignment operator by declaring them private if it makes sense to do so.

Even better is to use a compiler that uses link-time generation. This allows the compiler to see the "entire" program and as such perform global optimizations such as the above and many more.

Originally Posted by killme

Someone said to me once that when possible I should use static functions because it helps the compiler "in-line operations" (which I admittedly have no idea of the meaning). I was looking for documentation on this and found none and was hoping someone could clarify me on if/how that works. I'm actually not seeing the application of a static function in general and would appreciate some help there as well.

Inlineing is the act of replacing a call to a function with the body of the function, thereby eliminating the overhead of calling a function. This can be a very fruitful optimization for some functions, such as very short functions. A compiler will first try to inline functions when compiling each translation unit, the cpp fle and all included headers, but can only do so if the function body is in the same translation unit. A compiler will also try to inline function when linking your whole project together, so even if a function is not marked static or inline, it may still be inlined anywhere. However, this second pass of inlining is generally less aggressive.


In C++ and C99 the preferred way to help the compiler inline functions is to put them in the header and marking them as inline. In C89, the inline keyword is not available, so as an an alternative way of putting functions in headers for inlineing is by marking them static. The two key words are not mutually exclusive, so you could also declare a function as static inline, though why you would is dubious. C++ also provides a facility called unnamed namespaces that is almost identical to static functions in behavior.

The inline keyword allows a function to be declared in multiple translation units, provided that the same sequence of tokens is used to define the function. So you can put the function in the header. Note that if you don't use the same sequence of tokens, the compiler is not required to issue a diagnostic.

The static keyword allows multiple copies of a function to exist, one per translation unit. This has a similar effect of allowing you to put the definition in the header, but is less efficient for the compiler. Also, the compiler may warn you about unused static functions if set to do so. Static function may be useful for purposes other than inlining.

Unnamed namespaces are identical in what I described about static functions, and are prefered over static functions, mostly for elegance reasons; unnamed namespaces can wrap more than just functions. They also be used as template arguments, whereas static functions can't. I suspect, however, that there are rare cases that static functions could be optimized better than unnamed namespaces, due to the details of how they are commonly implemented.

In the three alternatives, static variables inside the function behave differently. For an inline functions, there is one version of each static variable in the whole program. For static and unnamed namespace functions, there is one version for each translation unit. Of course, static function variables should be avoided anyway because they have global scope and because they are not thead safe.


Putting a function in the header and marking it inline (or static) is an optimization tweak, which I'd recommend not using unless performance is critical and you're profiling to establish that it helps.

Originally Posted by samcpp

When a member function is declared as static, it can access only other static members and not non-static members.

Not true. Any function, static or otherwise, can access non-static members of a class if they have a pointer or reference to an instance of that class.

Code:

#include <iostream>
class X
{
    public:

        X() : x(42) {};
        static int get();

     private:
        int x;
}

X a;

int X::get()
{
    return a.x;
}

int main()
{
     std::cout << X::get() << '\n';
     return 0;
}

Originally Posted by samcpp

Since memory to member function is allocated only once, static member function is also created with other member functions and its definition appears within class unlike static data. It is not the member any object and created for class, which is always called with the class name and ( :: )

The first sentence here is incorrect to the point of being meaningless. Some implementations (aka compilers, etc) might do it that way, but there is no requirement that they do so.

The second sentence is incorrect, since a non-static member function of a class can call a static member of that class without qualification (i.e. without using the scope operator). [There are some possibilities for ambiguity if a "using" directive is in play, but that's another story.].

Originally Posted by samcpp

Find the Example with explanation:
cbtSAM FREE computer Training / Tutorials, cpp Static functions

I'll pass. Two out of two examples of your site are demonstrably wrong. That is not a glowing testament to quality of examples on your site.

Originally Posted by grumpy

Two out of two examples of your site are demonstrably wrong.

not to mention the code formatting is literally nonexistent. you have no indentation, making brace matching extremely difficult, and it just generally makes your code unpleasant to read.

Moreover the OP is asking about the kind of static functions that pertain to inlining, not static class members. So your comments are not only wrong, they're also about something completely different.