How do you avoid using global variables in inherently stateful programs?

Question

I am currently writing a small game in C and feel like I can't get away from global variables.

For example I am storing the player position as a global variable because it's needed in other files. I have set myself some rules to keep the code clean.

1. Only use a global variable in the file it's defined in, if possible

2. Never directly change the value of a global from another file (reading from another file using extern is okay)

So for example graphics settings would be stored as file scope variables in graphics.c. If code in other files wants to change the graphics settings they would have to do so through a function in graphics.c like graphics_setFOV(float fov).

Do you think those rules are sufficient for avoiding global variable hell in the long term?

How bad are file scope variables?

Is it okay to read variables from other files using extern?

Answer 1

Typically, this kind of problem is handled by passing around a shared context:

graphics_api.h

#ifndef GRAPHICS_API
#define GRAPHICS_API

typedef void *HANDLE;

HANDLE init_graphics(void);
void destroy_graphics(HANDLE handle);
void use_graphics(HANDLE handle);

#endif

graphics.c

#include <stdio.h>
#include <stdlib.h>
#include "graphics_api.h"

typedef struct {
    int width;
    int height;
} CONTEXT;

HANDLE init_graphics(void) {
    CONTEXT *result = malloc(sizeof(CONTEXT));
    if (result) {
        result->width = 640;
        result->height = 480;
    }
    return (HANDLE) result;
}

void destroy_graphics(HANDLE handle) {
    CONTEXT *context = (CONTEXT *) handle;
    if (context) {
        free(context);
    }
}

void use_graphics(HANDLE handle) {
    CONTEXT *context = (CONTEXT *) handle;
    if (context) {
        printf("width  = %5d\n", context->width);
        printf("height = %5d\n", context->height);
    }
}

main.c

#include <stdio.h>
#include "graphics_api.h"

int main(void) {
    HANDLE handle = init_graphics();
    if (handle) {
        use_graphics(handle);
        destroy_graphics(handle);
    }
    return 0;
}

Output

width  =   640
height =   480

Hiding the details of the context by using a void pointer prevents the user from changing the data contained within the memory to which it points.

Answer 2

The first thing you have to ask yourself is: Just why did the programming world come to loath global variables? Obviously, as you noted, the way to model a global state is essentially a global (set of) variable(s). So what's the problem with that?

The Problem

All parts of the program have access to that state. The whole program becomes tightly coupled. Global variables violate the prime directive in programming, divide and conquer. Once all functions operate on the same data you can as well do away with the functions: They are no longer logical separations of concern but degrade to a notational convenience to avoid large files.

Write access is worse than read access: You'll have a hard time finding out just why on earth the state is unexpected at a certain point; the change can have happened anywhere. It is tempting to take shortcuts: "Ah, we can make the state change right here instead of passing a computation result back up three layers to the caller; that makes the code much smaller."

Even read access can be used to cheat and e.g. change behavior of some deep-down code depending on some global information: "Ah, we can skip rendering, there is no display yet!" A decision which should not be made in the rendering code but at top level. What if top level renders to a file!?

This creates both a debugging and a development/maintenance nightmare. If every piece of the code potentially relies on the presence and semantics of certain variables — and can change them! — it becomes exponentially harder to debug or change the program. The code agglomerating around the global data is like a cast, or perhaps a Boa Constrictor, which starts to immobilize and strangle your program.

Such programming can be avoided with (self-)discipline, but imagine a large project with many teams! It's much better to "physically" prevent access. Not coincidentally all programming languages after C, even if they are otherwise fundamentally different, come with improved modularization.

So what can we do?

The solution is indeed to pass parameters to functions, as KamilCuk said; but each function should only get the information they legitimately need. Of course it is best if the access is read-only and the result is a return value: Pure functions cannot change state at all and thus perfectly separate concerns.

But simply passing a pointer to the global state around does not cut the mustard: That's only a thinly veiled global variable.

Instead, the state should be separated into sub-states. Only top-level functions (which typically do not do much themselves but mostly delegate) have access to the overall state and hand sub-states to the functions they call. Third-tier functions get sub-sub states, etc. The corresponding implementation in C is a nested struct; pointers to the members — const whenever possible — are passed to functions which therefore cannot see, let alone alter, the rest of the global state. Separation of concerns is thus guaranteed.

Answer 3

How do you avoid using global variables in inherently stateful programs?

By passing arguments...

// state.h
/// state object:
struct state {
    int some_value;
};
/// Initializes state
/// @return zero on success
int state_init(struct state *s);
/// Destroys state
/// @return zero on success
int state_fini(struct state *s);
/// Does some operation with state
/// @return zero on success
int state_set_value(struct state *s, int new_value);
/// Retrieves some operation from state
/// @return zero on success
int state_get_value(struct state *s, int *value);

// state.c
#include "state.h"
int state_init(struct state *s) {
    s->some_value = -1;
    return 0;
}
int state_fini(struct state *s) {
    // add free() etc. if needed here
    // call fini of other objects here
    return 0;
}
int state_set_value(struct state *s, int value) {
    if (value < 0) { 
        return -1; // ERROR - invalid argument
                   // you may return EINVAL here
    }
    s->some_value = value;
    return 0; // success
}
int state_get_value(struct state *s, int *value) {
    if (s->some_value < 0) { // value not set yet
        return -1;
    }
    *value = s->some_value;
    return 0;
}

// main.c
#include "state.h"
#include <stdlib.h>
#include <stdio.h>
int main() {
    struct state state; // local variable
    int err = state_init(&state);
    if (err) abort();

    int value;
    err = state_get_value(&state, &value);
    if (err != 0) {
        printf("Getting value errored: %d\n", err);
    }

    err = state_set_value(&state, 50);
    if (err) abort();
    err = state_get_value(&state, &value);
    if (err) abort();
    printf("Current value is: %d\n", value);

    err = state_fini(&state);
    if (err) abort();
}

The only single case where global variables (preferably only a single pointer to some stack variable anyway) have to be used are signal handlers. The standard way would be to only increment a single global variable of type sig_atomic_t inside a signal handler and do nothing else - then execute all signal handling related logic from the normal flow in the rest of the code by checking the value of that variable. (On POSIX system) all other asynchronous communication from the kernel, like timer_create, that take sigevent structure, they can pass arguments to notified function by using members in union sigval.

Do you think those rules are sufficient for avoiding global variable hell in the long term?

Subjectively: no. I believe that a potentially uneducated programmer has too much freedom in creating global variables given the first rule. In complex programs I would use a hard rule: Do not use global variables. If finally after researching all other ways and all other possibilities have been exhausted and you have to use a global variables, make sure global variables leave the smallest possible memory footprint.

In simple short programs I wouldn't care much.

How bad are file scope variables?

This is opinion based - there are good cases where projects use many global variables. I believe that topic is exhausted in are global variables bad and numerous other internet resources.

Is it okay to read variables from other files using extern?

Yes, it's ok.

There are no "hard rules" and each project has it's own rules. I also recommend to read c2 wiki global variables are bad.