Thread: Large number of variables needing global scope

I have a lot of globals in my program. Much of the program operation is related
to setting and modifying various parameters, switches, flags, etc.
Also changing operating modes, adding and removing indicators; in other words,
all kinds of stuff.

The program uses functions as subroutines to carry out the various operations.
They don't return values as many library functions do, they just perform some
operation. Subroutines.

I could put everything in a big structure, and pass the structure address around,
but that would basically give almost all the functions access to them. Which is
one of the complaints about globals.

One main part of the program's function is to generate fractal based images, and
allow magnification of any selected part. The other main part provides setting up
and editing a color spectrum which is used to color the image. Most operations are
activated by mouse and keboard; some of the new ones will be in menus.
It's not a complicated program, a main command interpreter and mouse interpreter
call all the appropriate functions. But their operations affect many of the (global)
variables.

Does the number of variables in question have anything to do with whether or not
globals are appropriate? In other words if one particular global variable was
appropriate, would a large number of such variables also be appropriate?

And also, what is the best way to deal with large numbers of variables that require
such large scope?

General best strategy is to keep the number of global variables to an absolute minimum. Whenever possible pass stuff around between functions rather than have it all hanging out in the open... The shorter the lifetime of a variable the less chance of something screwing it up.

As a rule I will put settings into a struct, as bit flags when possible, at global scope. I may globalize the main window handle and perhaps the instance handle, in window GUI programs. The rest will be either passed around between functions or exist at page scope in a single file.

I have been trying to minimize the globals. It's actually not easy because it has always been
my programming style to use them. I don't have to conform to an employer's standard or an
acedemic standard. Even the software that I did write for an employer was for in-house use
only, and I was free to use whatever necessary to get it done.

I can understand that there a good reason for rules like "don't use globals". But I also noticed
that the common programming style is maybe different from what I use. It seems like globals
are rarely needed, when looking at typical examples of programs. It also seems though, that
my programs aren't quite structered like those either.

I am getting a sense that I am not structuring the program right and that is why I need to use
globals. I will post my program as soon as I have cleaned up all the extraneous stuff. Much of
it is experimental, as I am trying out various color rendering tools. But it is settling down and I
can soon post the source code.

But for the present, I was just wondering if the number of globals mattered; if you simply need
a whole bunch of them, is that Ok?

But for the present, I was just wondering if the number of globals mattered; if you simply need
a whole bunch of them, is that Ok?

Nope, it's not. I get the sense that you know what all this data is for, so why don't you focus on separating it. For example:

One main part of the program's function is to generate fractal based images, and
allow magnification of any selected part. The other main part provides setting up
and editing a color spectrum which is used to color the image.

These are very separate jobs, and the 64,000 dollar question (worth your (possible) wages) is do you really work with the same data when you are coloring the image as when you are magnifying? Can the image itself be a separate thing? Once you create types, you'll find it's easier to break up a problem. That's an OOPism, but you can easily do the inverse. What steps needs to happen to accomplish a goal and what data do you need for every solitary step? That can also help you break up the problem into tiny problems, and organize data.

Following upon whiteflags, I also extend that to what source pages things are on... For example, again in windows Gui mode... treeview controls bring a lot of overhead to a program so I will put all the functions related to a treeview on one source page... same with listviews, dialogs, and such. Plus I never put code in switch statements ( a cause of considerable disorganization in windows). What I do instead is use the switch statement to call functions, which encapsulates the code and makes debugging a lot simpler.

Those two main parts of the program do use two separate sets of variables. But each of those
have several subroutines with each using many variables.

I do really need to post the code. I will do so as soon as I clean it up.

I have to warn all you though - no comments!

On the other hand, it is quite neat and should be sufficient for the question at hand.

Am starting a new topic with source code, for advice on that particular program.

I'll leave this one here for general info on globals.

Um, people who start several threads on ostensibly the same thing become unpopular quickly. You already told us what the program does so it's not off topic.