Pointer to function vs global variable

Question

New EE with very little software experience here. Have read many questions on this site over the last couple years, this would be my first question/post. Haven't quite found the answer for this one.

I would like to know the difference/motivation between having a function modify a global variable within the body (not passing it as a parameter), and between passing the address of a variable.

Here is an example of each to make it more clear. Let's say that I'm declaring some functions "peripheral.c" (with their proper prototypes in "peripheral.h", and using them in "implementation.c"

Method 1:

//peripheral.c

//macros, includes, etc

void function(*x){
   //modify x
}

.

//implementation.c

#include "peripheral.h"

static uint8 var;

function(&var);  //this will end up modifying var

Method 2:

//peripheral.c

//macros, includes, etc

void function(void){
   //modify x
}

.

//implementation.c

#include "peripheral.h"

static uint8 x;

function();    //this will modify x

Is the only motivation to avoid using a "global" variable? (Also, is it really global if it just has file scope?)

Hopefully that question makes sense. Thanks

Answer 1

The main problem with global variables is that they promote what's known as "tight coupling" between functions or modules. In your second design, the peripheral module is aware of and dependent on the design of implementation, to the point that if you change implementation by removing or renaming x, you'll break peripheral, even without touching any its code. You also make it impossible to re-use peripheral independently of the implementation module.

Similarly, this design means function in peripheral can only ever deal with a single instance of x, whatever x represents.

Ideally, a function and its caller should communicate exclusively through parameters, return values, and exceptions (where appropriate). If you need to maintain state between calls, use a writable parameter to store that state, rather than relying on a global.

Answer 2

First of all, in C/C++, "global" does mean file scope (although if you declare a global in a header, then it is included in files that #include that header).

Using pointers as parameters is useful when the calling function has some data that the called function should modify, such as in your examples. Pointers as parameters are especially useful when the function that is modifying its input does not know exactly what it is modifying. For example:

scanf("%d", &foo);

scanf is not going to know anything about foo, and you cannot modify its source code to give it knowledge of foo. However, scanf takes pointers to variables, which allows it to modify the value of any arbitrary variable (of types it supports, of course). This makes it more reusable than something that relies on global variables.

In your code, you should generally prefer to use pointers to variables. However, if you notice that you are passing the same chunk of information around to many functions, a global variable may make sense. That is, you should prefer

int g_state;
int foo(int x, int y);
int bar(int x, int y);
void foobar(void);
...

to

int foo(int x, int y, int state);
int bar(int x, int y, int state);
void foobar(int state);
...

Basically, use globals for values that should be shared by everything in the file they are in (or files, if you declare the global in a header). Use pointers as parameters for values that should be passed between a smaller group of functions for sharing and for situations where there may be more than one variable you wish to do the same operations to.

EDIT: Also, as a note for the future, when you say "pointer to function", people are going to assume that you mean a pointer that points to a function, rather than passing a pointer as a parameter to a function. "pointer as parameter" makes more sense for what you're asking here.

Answer 3

I'm not sure your second example really works, since you declared x as static (and thus limiting its scope to a file) but other then that, there are some advantages of the pointer passing version:

• It gives you more flexibility on allocation and modularity. While you can only have only one copy of a global variable in a file, you can have as many pointers as you want and they can point to objects created at many different places (static arrays, malloc, stack variables...)

• Global variables are forced into every function so you must be always aware that someone might want to modify them. On the other hands, pointers can only be accessed by functions you explicitely pass them to.

• In addition to the last point, global variables all use the same scope and it can get cluttered with too many variables. On the other hand, pointers have lexical scoping like normal varialbes and their scope is much more restricted.

---

And yes, things can get somewhat blurry if you have a small, self contained file. If you aren't going to ever instantiate more then one "object" then sometimes static global variables (that are local to a single file) work just as well as pointers to a struct.

Answer 4

Several different issues here:

1. In general, "global variables are bad". Don't use them, if you can avoid it. Yes, it preferable to pass a pointer to a variable so a function can modify it, than to make it global so the function can implicitly modify it.

2. Having said that, global variables can be useful: by all means use them as appropriate.

3. And yes, "global" can mean "between functions" (within a module) as well as "between modules" (global throughout the entire program).

4. There are several interesting things to note about your code:

   a) Most variables are allocated from the "stack". When you declare a variable outside of a function like this, it's allocated from "block storage" - the space exists for the lifetime of the program.

   b) When you declare it "static", you "hide" it from other modules: the name is not visible outside of the module.

   c) If you wanted a truly global variable, you would not use the keyword "static". And you might declare it "extern uint8 var" in a header file (so all modules would have the definition).

Answer 5

The function that receives a parameter pointing to the variable is more general. It can be used to modify a global, a local or indeed any variable. The function that modifies the global can do that task and that task only.

Which is to be preferred depends entirely on the context. Sometimes one approach is better, sometimes the other. It's not possible to say definitively that one approach is always better than the other.

As for whether your global variable really is global, it is global in the sense that there is one single instance of that variable in your process.

Answer 6

static variables have internal linkage, they cannot be accessed beyond the translation unit in which they reside.

So if you want to modify a static global variable in another TU it will be have to be passed as an pointer through function parameter as in first example.

Your second example cannot work because x cannot be accessed outside implementation.c, it should give you an compilation error.

Good Read:
What is external linkage and internal linkage?