On 19/09/2013 07:41, DeMarcus wrote:
Global variables are "evil" but global /objects/ are
not. However, with global objects come their constructors that
must run before main() if you don't make them pointers.
I am curious, what do you consider to be the difference between a
variable and an object? Why, globally, is the former bad whilst
the latter is not?
Perhaps explaining why global variables are bad (I would say,
'should be avoided if possible) would be a start (yes I think I
know the answer).
Global variables are as bad as public variables. Objects using them
are impossible to keep consistent with invariants. A global
/object/ on the other hand can still be kept consistent.
You are still missing the point. You seem to think that there is
some essential difference in C++ between a variable and an
object. If you want to define what you mean by an object that
distinguishes it from a variable we might then be able to have a
more meaningful dialogue.
The issue with globals is not about maintaining their internal
consistency but about the consequences of having them accessible
from many places in a program. That makes testing much harder and
more complex. It also makes predicting outcomes much harder.
Here is a simple example to highlight one of the problems
class object {
// some suitable definition providing
// all the possible benefits from
// encapsulation
};
object obj{/* initialisation data */}
void foo(object const & o);
int main(){
object obj1{obj}; // create a copy of the global
foo(obj1);
foo(obj); // call foo with the global
std::cout << (obj == obj1 ? "X" : "Y") << std::endl; // A
}
What is the expected output? It is impossible to answer without
knowing the detail of foo()'s definition and the definitions of all
functions called by foo() (recursively) I.e. you need to know the
full details of the implementation of foo().
Here is a trivial definition of foo() that would generate 'Y' as
output:
void foo(object const & o){ obj.modify();}
// with modify changing the state of an instance of type object
Once we have a global non-const 'object' we have no certainty as to
its state once we call a function and pass it a reference or pointer
to that object.
You have a good point there. One should be careful with global
objects. If you have global objects you should never pass them
around.
A global object shouldn't be just any object. It should be a type that
is used as a global object only. Some examples from other programming
etc.
[ comp.lang.c++.moderated. First time posters: Do this! ]