Use of global variables in C++ application

Question

I’ve used global variables without having any noticeable problems but would like to know if there are potential problems or drawbacks with my use of globals.

In the first scenario, I include const globals into a globals.h file, I then include the header into various implementation files where I need access to any one of the globals:

globals.h
const int MAX_URL_LEN = 100;
const int MAX_EMAIL_LEN = 50;
…

In the second scenario, I declare and initialize the globals in an implementation file when the application executes. These globals are never modified again. When I need access to these globals from a different implementation file, I use the extern keyword:

main.cpp
char application_path[128];
char data_path[128];
// assign data to globals
strcpy(application_path,  get_dll_path().c_str());
…

do_something.cpp
extern char application _path[]; // global is now accessible in do_something.cpp

Regarding the first scenario above, I’ve considered removing all of the different “include globals.h” and using extern where access to those globals is needed but have not done so since just including the globals.h is so convenient.

I am concerned that I will have different versions of the variables for each implementation file that includes globals.h.

Should I use extern instead of including the globals.h everywhere access is needed?

Please advise, and thank you.

Answer 1

Global mutable variables

• provide invisible lines of influence across all of the code, and
• you cannot rely on their values, or whether they've been initialized.

That is, global mutable variables do for data flow what the global goto once did for execution flow, creating a spaghetti mess, wasting everyone's time.

Constant global variables are more OK, but even for those you run into

• the initialization order fiasco.

I remember how angry I got when I realized that all my troubles in wrapping a well known GUI framework, was due to it needlessly using global variables and provoking the initialization order fiasco. First the anger was directed at the author, then at myself for being so stupid, not realizing what was going on (or rather, was not going on). Anyway.

A sensible solution to all this is Meyers' singletons, like

inline
auto pi_decimal_digits()
    -> const string&
{
    static const string the_value = compute_pi_digits();
    return the_value;
}

For the case of a global that's dynamically initialized from some place that knows the value, “one programmer's constant is another programmer's variable”, there is no good solution, but one practical solution is to accept the possibility of a run time error and at least detect it:

namespace detail {
    inline
    auto mutable_pi_digits()
        -> string&
    {
        static string the_value;
        return the_value;
    }
}  // namespace detail

inline
void set_pi_digits( const string& value )
{
    string& digits = detail::mutable_pi_digits();
    assert( digits.length() == 0 );
    digits = value;
}

inline
auto pi_digits()
    -> const string&
{ return detail::mutable_pi_digits(); }