Re: side effects?
"Senthil" <s.senthilvel@gmail.com> wrote in message
news:1182921273.603982.88330@z28g2000prd.googlegroups.com...
Hi,
Whenever i read a C++ book or a newsgroup posting, i come across the
terms like " before the side effects completes" , "destructor with
side effects" etc. What is this side effect mean in C++ world?
Is it like something that is not desired but happens automatically and
we cannot prevent it?
Would be great if someone throws light on this.
Consider a simple side effect, someone writes a class and wants to keep
track/debug constructors, destructors and such and so in each does std::cout
<< "Class X Constructor", std::cout << "Class X Destructor", std::cout <<
"Class X Copy Constructor", etc...
Those are side effects (the outputs). Compilers may be free to not do a
copy constructor when one would normally be done if it can do it more
effeciently some other way. For example, say there is an instruciton that
would normally create a temporary object using a constructor then use a copy
constructor to create an object (or assignment operator). The compiler may
just deside to create the object directory from the constructor doing away
with the copy or assignments. Normally, that's fine, but in this case we
don't see the side effects, the output of "Class X Copy Constructor", etc...
It is a little more detailed than that, that is a simplistic description
because I really don't know all what exactly makes up a side effect. I do
know that it is often refered to in if statments:
if ( A || B )
B may not always be evaluated (if A is true then the if statment is
short-circuited, only A is evaluated) and so if B has side effects you may
expect to see them but may not. Consider a simplistic case: (untested code)
class Foo
{
public:
Foo( bool Enable ): Enabled_( Enable ) {}
bool Enabled() { std::cout << "Checking if enabled...\n'; return
Enabled_; }
private:
bool Enabled_;
}
int main()
{
bool Bar = true;
Foo Foobar( false );
if ( Bar || Foo.Enabled() }
std::cout << "One is true...\n";
}
At first glance, one may expect the output of this program to be:
Checking if enabled...
One is true...
But the output will most likely be:
One is true...
Because of short circuiting, Foo.Enabled() is not evaluated and it's "side
effects" are not performed.