What is the best strategy for sharing variables between source files in c/c++?

Question

I frequently have to write c/c++ programs with 10+ source files where a handful of variables need to be shared between functions in all the files. I have read before that it is generally good practice to avoid using global variables with extern. However, if it is completely necessary to use global variables, this link provides a good strategy. Lately, I have been toying with the strategy of wrapping up all my variables in a struct or a class and passing this struct around to different functions. I was wondering which way people consider to be cleaner and if there are any better alternatives.

EDIT: I realize strategies may be different in the two languages. I am interested in strategies that apply to only one language or both.

Answer 1

Pass around a class/struct of "context" data instead of global variables. You will be suprised how often a global variable becomes no longer global, with different modules wanting to use different values for it at the same time.

Answer 2

My take in C++

I found it a good practice in C++ anyway to limit the scope of my global variables with a namespace. That way you can eliminate any ambiguity between your 10+ source files.

For example:

namespace ObjectGlobalVars {
   //Put all of your global variables here
   int myvariable = 0;
}

//And then later on you can reference them like
ObjectGlobalVars::myvariable++;

Answer 3

Does it REALLY need to be global?

This is the first question you should always ask, is this variable used GLOBALLY e.g. in all contexts. The answer is almost certainly... no it's not.

Consider Context

Is the variable global state, or is it context? Global state is usually rare, context on the other hand is quite common. If it's global state consider wrapping in a singleton so you can manage the how of interaction with your globals. Using Atomic<> is probably not a bad idea, you should at least consider synchronization.

If it is context then it should be passed explicitly in a structure or class, as the data is explicitly relevant to that context an no-other. Passing context explicitly may seem like a burden but it makes it very clear where the context is coming from rather than just referencing random variables out of the ether.

What is the Scope?

It may seem odd to say that globals are scoped, but any global declared in a single file may be declared static and thus unlinkable from any other file. This means you can restrict who has access to the global state in a given scope. This allows you to prevent people from randomly tweaking variables.

Answer 4

The better alternative to globals is to not use globals.

Don't try to sweep them under the rug using a struct or a namespace or a singleton or some other silly thing whose only purpose is to hide the fact that you're using globals.

Just don't ever create one. Ever.

It will force you to think of ownership and lifetime and dependencies and responsibility. You know, grown-up things.

And then, when you're comfortable writing global-free code, you can start violating all those rules.
Because that's what rules are for: to be followed, and to be broken.

Answer 5

In c++
Having global variables lying around here and there, is an example of bad code.
If you want to share things on a global scale, then group them up and follow the singleton pattern.

Example:

class Singleton
{
    private:
        int mData;

    public:
        static Singleton& getInstance()
        {
            static Singleton instance;
            return instance;
        }
        int GetData()
        {
            return mData;
        }
    private:
        Singleton() {};
        Singleton(Singleton const&);
        void operator=(Singleton const&);
};

Advantages:

• Only 1 global variable. The instance of our singleton.

• You can include mutex / semaphore mechanisms inside the singleton, for thread-safe access of it's members.

• Restricts the access of it's members helping you avoid logical and synchronization flaws.

Disadvantages:

• Harder to implement. - If it's your first time -

In c
You should avoid declaring global variables, pass them in structs instead.

For instance:

struct MyData
{
    int a;
    int b;
};

void bar(struct MyData* data)
{
    data->b = 2;
}

void foo()
{
    struct MyData mdata;
    mdata.a = 1;

    bar( &mdata );
}

To sum things up
Having global variables lying around should be avoided as much as possible, in both languages.