I understand though, that functions already have all max lifespan, and that local vars are already scope-limited. But I think that this definition helps understand why the same keyword is used in all cases.

I have very little insight in compilers, but I suspect that the parser does just that when encountering static?

By that little define one adds quite a bit of readability to the code, yet complies to the standard.

Something valuable learned here!

Matthias

I think OO programming is not widely used within embedded programming, so I’ll clarify: Within C++, a ‘class’ is basically the same thing as a ‘struct’. The ONLY difference, and I truly mean ONLY, is that in a struct, members are by default public (anyone who has a pointer to an instance of a struct has free access to its members), while in a class, members are by default private and must be declared public in order for outsiders to access them. In C++, a class/struct can “contain” functions, which in OO parlance are usually called ‘methods’, though it means the same thing. Instead of having bits & pieces of code scattered throughout various functions all over your codebase that operate on data in a class/struct, in OOP, you group the data and the bits & pieces of code that operate on that data together inside the class/struct. And generally, if a you don’t put any functions in the class/struct, you call it a struct, otherwise you call it a class. Now when you create objects of these classes, they don’t get extra copies of the code for the functions inside the class, there’s really only one copy of the functions, but conceptually you can just go ahead and think of it as if they all have their own copies. But ‘static’ members are different: conceptually, you should (because it’s correct) think of a static member as having only a single instance regardless of how many objects of that type are created. So, for example, you could have a single static bool flag to flip all objects of that type between debug & normal modes. When you set the static bool debug flag true, it’s true for all objects of that type. In this sense, it’s sort of like a global variable, but it’s grouped within the class definition because OO programmers tend to shudder at the thought of anything other than main() being global. In addition to static class variables, a class can have static methods. Static methods (functions) can be called directly; in a sense, they’re sort of like global functions, but, ah, no, forget I said that. If you have non-static class methods, these can only be “called on” an object of that type that already exists. So, for example, if you have a class that contains a set of numbers, you might want to sort them. So you would have a member method to tell an object of that type to sort itself. If you have an object of your class numberList that you’ve named “myPhoneList”, you could call myPhoneList->sort(), and it would sort itself. But sometimes the purpose of a method doesn’t exactly apply to a specific object of that type. For example, you might want to know how many numberLists objects are in existence. For that purpose, you don’t need any specific object of that type to find this out; your numberList class probably has a static member variable named instanceCount, but like all good OO programmers you made it private so nobody can see it. But you made a method so folks can find out its value without accessing it directly, and of course it’s a static method because it doesn’t deal with any data related to any specific numberList. Now anybody who knows that the numberList class exists can find out how many numberLists are out there floating around in memory without actually knowing where any of them are.

If a function is declared “static”, and you don’t take its address, then the compiler knows it cannot be called outside the module. It is therefore free to inline it, remove it, simplify it, change its calling conventions, or otherwise optimise it as it sees fit. Whether this will reduce code size or not will depend on the compiler and your optimisation settings, but you are giving the compiler the best chance to do a better job.

With modern compilers, you should not have to explicitly declare a static function as “inline” unless you believe the compiler will do a poor job on its own (compiler heuristics are normally good, but not perfect). In those cases, you may need something additional such as __attribute__((always_inline)) to force the behaviour you want. Of course, sometimes adding “inline” makes your code clearer, in which case it’s a good thing. But otherwise let the compiler make the decision.

There are occasions when you want to use “static” in header files. But remember that the data or functions are then independent for each module that includes the header. Thus the main uses for “static” in header is for a modern and type-safe (at least, as type-safe as it gets in C/C++) replacements for pre-processor defines. For example, you can replace:

#define magicNumber 100
#define magicFormula(x) ((x) * (x) + magicNumber)

with

static const int magicNumber = 100;
static inline int magicFormula(int x) { return x * x * magicNumber; }

But since they still exist, you are free to take their address and pass it around the rest of the program. Passing the address of a function-local static variable, for example, is perfectly valid and perfectly safe.

Of course, the optimisation advantages of statics are mostly lost if you take its address and pass it outside the current compilation unit. For example, the compiler will generate the full code for a static function rather than inlining it if you’ve taken its address. And a “static const int” might be optimised away entirely by the compiler if you don’t take its address.