Thread: Use global variables or pointers?

I have been reading up in my C++ books and all of them say that using global variables is not very 'safe' and a few books say its down right dangerous. Im curious if it is considered good programming practice to use pointers in place of global variables. Also, is it a bad idea to use so many pointers?

I don't see how using global variables is unsafe.
I do see how it's bad programming practice though. Having stuff available from all over your program doesn't sound very practical and has a tendency of making your source code into an intangible mess where everything's accessed from everywhere.
Once a bug gets into code like that, it'll become VERY hard to figure out what's causing the problem.

(edit) Also, what Ancient Dragon said.

[preach]
Pointer. The more pointers the better.

Never EVER use global variables. Maybe once in your life it will be okay. But other than that, do NOT use global variables.
[/preach]

So yeah, the great thing about global variables is that you can use them through all your code, change them where you like, and not have to worry about passing values back and forth. The downfall of global variables is that they can be changed anywhere by anything, since there's no restriction on access to the variable. When anything can access your variable, that's when problems can start to happen.

Pointers, if you can manage to get your brain around them (it usually takes a while before people get comfortable with them) are fantastic.

Imagine having a big structure filled with people's names, phone numbers, addresses, etc. And you have one million of these. Without pointers, your program is required to copy ALL the data over into a new variable, i.e.

Code:

int AddOne(int Value)
{
return Value + 1;
}

int main(void)
{
int X = 0;

X = AddOne(X);

return 0;
}

Sorry, no access to a TAB to make the code pretty

But in that example, when AddOne() is called, the contents of X must be COPIED over to Value, and then when the return happens, the contents of Value+1 are COPIED back over to X. Now, with one int, it isn't that big of a deal. But get millions of big structures, that take up alot of memory to begin with, you can find yourself in trouble easily.

However, with a pointer, all you'll do is pass the value by reference. This means, that instead of COPYING the contents of the variable, you're only copying over the value of the Address of the variable. It's much faster/efficient to copy only an address and say, "Hey, look over here, here's the data you want, change it however you see fit", than spend the time dumping variable after variable into whatever empty memory you can find.

So, there's my two cents. I'm sure you'll have close to a dollar by the time everyone's through with this. But hope it helps clear a couple of things up.