This code must have crashed....but works fine

[hsharsha]

Consider the below code snippet:

#include <iostream>
using namespace::std;

class myclass
{
public:
myclass() {
cout << "constructo r" << endl;
}
~myclass() {
cout << "destructor " << endl;
}
void func() {
cout << "func" << endl;
}
};

int main(void) {
myclass *obj = new myclass();
delete obj;
obj = NULL; // obj = (myclass*)0;
obj->func(); //..............m ust be a crash..... but works fine
return 0;
}

i tried the above code in Microsoft compiler 12.0, 13.0 and g++.
the code doesnt crash and the output will be like
constructor
destructor
func

i really dont know how when obj is null, obj->func() is valid and not
crashing ?????????????/

anybody has an idea about it ??????????

regards,
Harsha.

[Thomas J. Gritzan]

hs******@gmail. com schrieb:

Consider the below code snippet:

[snip]

int main(void) {
myclass *obj = new myclass();
delete obj;
obj = NULL; // obj = (myclass*)0;
obj->func(); //..............m ust be a crash..... but works fine
return 0;
}

i tried the above code in Microsoft compiler 12.0, 13.0 and g++.

Where did you get that compiler? MS C++ is at version 8.0.

the code doesnt crash and the output will be like
constructor
destructor
func

i really dont know how when obj is null, obj->func() is valid and not
crashing ?????????????/

Your code invokes undefined behaviour by dereferencing a null-pointer.
Undefined means, the compiler is free to do everything it wants: It might
appear to work this time, or it might format your hard disk.

--
Thomas

[Thomas Tutone]

hshar...@gmail. com wrote:

Consider the below code snippet:

#include <iostream>
using namespace::std;

class myclass
{
public:
myclass() {
cout << "constructo r" << endl;
}
~myclass() {
cout << "destructor " << endl;
}
void func() {
cout << "func" << endl;
}
};

int main(void) {
myclass *obj = new myclass();
delete obj;
obj = NULL; // obj = (myclass*)0;
obj->func(); //..............m ust be a crash..... but works fine

Actually, that merely results in undefined behavior.

return 0;
}

i tried the above code in Microsoft compiler 12.0, 13.0 and g++.
the code doesnt crash and the output will be like
constructor
destructor
func

i really dont know how when obj is null, obj->func() is valid and not
crashing ?????????????/

anybody has an idea about it ??????????

When you have undefined behavior, that means anything could happen.
For example (1) the program might crash, (2) the program might work as
if you had a valid object (since your class has no members and
therefore the null pointer is never dereferenced), or (3) the program
might print "Harsha uses far too many question marks ('?') in his
postings" on your console over and over again. If it's undefined, you
just don't know.

Best regards,

Tom

[Rolf Magnus]

hs******@gmail. com wrote:

Consider the below code snippet:

#include <iostream>
using namespace::std;

class myclass
{
public:
myclass() {
cout << "constructo r" << endl;
}
~myclass() {
cout << "destructor " << endl;
}
void func() {
cout << "func" << endl;
}
};

int main(void) {
myclass *obj = new myclass();
delete obj;
obj = NULL; // obj = (myclass*)0;
obj->func(); //..............m ust be a crash..... but works fine

The C++ standard doesn't require any code to 'crash'.

return 0;
}

i tried the above code in Microsoft compiler 12.0, 13.0 and g++.
the code doesnt crash and the output will be like
constructor
destructor
func

i really dont know how when obj is null, obj->func() is valid and not
crashing ?????????????/

What makes you think there is no other possible outcome than a 'crash'?

anybody has an idea about it ??????????

Try to repair your '?' key. It seems broken.

[Philip Potter]

<hs******@gmail .comwrote in message
news:11******** **************@ i42g2000cwa.goo glegroups.com.. .

i really dont know how when obj is null, obj->func() is valid and not
crashing ?????????????/

anybody has an idea about it ??????????

Unfortunately, C++ doesn't have strict rules about what happens when you do
something naughty like this. When you call obj->func(); with obj==NULL, the
behaviour is undefined. That means that it may, fortuitously, work exactly
as expected; but this is no guarantee that it works on any other compiler.

You may get different results if you add a variable to myclass and access it
from func(); you may not. Either way, you are correct, this code is wrong,
but the compiler may not be able to warn you about it.

Philip

[hsharsha]

Philip Potter wrote:

<hs******@gmail .comwrote in message
news:11******** **************@ i42g2000cwa.goo glegroups.com.. .

i really dont know how when obj is null, obj->func() is valid and not
crashing ?????????????/

anybody has an idea about it ??????????

Unfortunately, C++ doesn't have strict rules about what happens when you do
something naughty like this. When you call obj->func(); with obj==NULL, the
behaviour is undefined. That means that it may, fortuitously, work exactly
as expected; but this is no guarantee that it works on any other compiler.

You may get different results if you add a variable to myclass and access it
from func(); you may not. Either way, you are correct, this code is wrong,
but the compiler may not be able to warn you about it.

Philip

i tried it in microsoft cl 6.0, 7.0 and g++ (suprisingly same
behaviour). all the three give the same result. if its undefined, then
there must be some variations in the output, but its the same. i am
really confused.
i even tried adding a variable to the class, but the result was the
same. u guys can try it on any compiler and let me know if possible. i
doubt something in this.

[Howard]

<hs******@gmail .comwrote in message
news:11******** *************@m 73g2000cwd.goog legroups.com...

>
Philip Potter wrote:

><hs******@gmai l.comwrote in message
news:11******* *************** @i42g2000cwa.go oglegroups.com. ..

i really dont know how when obj is null, obj->func() is valid and not
crashing ?????????????/

anybody has an idea about it ??????????

Unfortunatel y, C++ doesn't have strict rules about what happens when you
do
something naughty like this. When you call obj->func(); with obj==NULL,
the
behaviour is undefined. That means that it may, fortuitously, work
exactly
as expected; but this is no guarantee that it works on any other
compiler.

You may get different results if you add a variable to myclass and access
it
from func(); you may not. Either way, you are correct, this code is
wrong,
but the compiler may not be able to warn you about it.

Philip

i tried it in microsoft cl 6.0, 7.0 and g++ (suprisingly same
behaviour). all the three give the same result. if its undefined, then
there must be some variations in the output, but its the same. i am
really confused.
i even tried adding a variable to the class, but the result was the
same. u guys can try it on any compiler and let me know if possible. i
doubt something in this.

The term "undefined" means that the Standard for C++ does not define what
the results should be. It is simply up to to you to avoid undefined
behavior at all times. It makes no difference if it happens to do the exact
same thing on every compiler and every computer in existence. It's improper
to do that, and the results are not specified by the Standard. You should
not rely on it working, or crashing, or on any specific behavior at all.
Just don't do that! :-)

-Howard

[Rolf Magnus]

hs******@gmail. com wrote:

><hs******@gmai l.comwrote in message
news:11******* *************** @i42g2000cwa.go oglegroups.com. ..

i really dont know how when obj is null, obj->func() is valid and not
crashing ?????????????/

anybody has an idea about it ??????????

Unfortunatel y, C++ doesn't have strict rules about what happens when you
do something naughty like this. When you call obj->func(); with
obj==NULL, the behaviour is undefined. That means that it may,
fortuitously , work exactly as expected; but this is no guarantee that it
works on any other compiler.

You may get different results if you add a variable to myclass and access
it from func(); you may not. Either way, you are correct, this code is
wrong, but the compiler may not be able to warn you about it.

Philip

i tried it in microsoft cl 6.0, 7.0 and g++ (suprisingly same
behaviour). all the three give the same result. if its undefined, then
there must be some variations in the output,

No. "Undefined" means that nothing is required. Not even that every compiler
behaves differently.

but its the same. i am really confused.

Why? It's simple. If you invoke undefined behavior, don't expect any specifc
or unspecific behavior. Just don't expect anything.

[Bo Persson]

"Thomas J. Gritzan" <Ph************ *@gmx.deskrev i meddelandet
news:ec******** **@newsreader2. netcologne.de.. .

hs******@gmail. com schrieb:

>Consider the below code snippet:

[snip]

>int main(void) {
myclass *obj = new myclass();
delete obj;
obj = NULL; // obj = (myclass*)0;
obj->func(); //..............m ust be a crash..... but works fine
return 0;
}

i tried the above code in Microsoft compiler 12.0, 13.0 and g++.

Where did you get that compiler? MS C++ is at version 8.0.

No, it's the Visual Studio that is at version 8.0 (or 2005), using the
interesting scheme 1, 2, oops, 4, etc.

The current C++ compiler is at version 14.0, counting its ancestry all
the way back to the very first (non-Visual) MS C compiler, version 3.0
(don't ask :-).
To be somewhat on topic, I must also add that undefined behaviour
doesn't at all mean "must crash", as other posters have pointed out.
The really nasty result is "seems to work".
Bo Persson

[Salt_Peter]

hs******@gmail. com wrote:

Consider the below code snippet:

#include <iostream>
using namespace::std;

class myclass
{
public:
myclass() {
cout << "constructo r" << endl;
}
~myclass() {
cout << "destructor " << endl;
}
void func() {
cout << "func" << endl;
}
};

int main(void) {
myclass *obj = new myclass();

....should be...
myclass* obj = new myclass;

delete obj;
obj = NULL; // obj = (myclass*)0;
obj->func(); //..............m ust be a crash..... but works fine
return 0;
}

i tried the above code in Microsoft compiler 12.0, 13.0 and g++.
the code doesnt crash and the output will be like
constructor
destructor
func

i really dont know how when obj is null, obj->func() is valid and not
crashing ?????????????/

Its undefined behaviour. Meaning that the result can't be guarenteed.
Undefined behaviour is often not a crash. Yet if you understand and
apply the concepts - UB is an important subject because
just_because_it _works does not mean its valid.

The only reason you never saw the "crash" is because the func() member
function isn't doing any work. Don't forget that the 'this' parameter
is passed to all non-const member functions. The fact that func() fails
to generate an access diagnostic is only because the obj's internals
are not being accessed.
Consider:

class myclass
{
int m_n;
public:
myclass() : m_n( 0 )
{
std::cout << "constructo r" << std::endl;
}
~myclass()
{
std::cout << "destructor " << std::endl;
}
void func()
{
std::cout << "func where m_n = " << m_n << std::endl;
}
};

The above class now does generate a crash when the zapped obj's access
is attempted...
The fact that the original did not crash is irrelevent, its still UB.
Undefined behaviour is about concepts, not results.