在C ++应用程序中使用全局变量

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

Your implementation is fine for now. Globals become a problem when

1. Your program grows and so does your number of globals.
2. New people join the team that don't know what you were thinking.

Number 1 becomes particularly troublesome when your program becomes multi-threaded. Then you have a number of threads using the same data and you may require protection, which is difficult with just a list of globals. By grouping data in separate files according to some criteria such as purpose or subject matter your code becomes more maintainable as it grows and you leave breadcrumbs for new programmers on the project to figure out how the software works.

Answer 2

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(); }

Answer 3

One issue with globals is that when you go to include 3rd party libraries in your code, sometimes they've used globals with the same names as yours. There are definitely times when a global makes sense, but if possible you should also take care to do something like put it into a namespace.