Re: Why pA->foo() works in this code?
Luis Angel Fernandez Fernandez wrote:
Hi
why this code works?
#include <iostream>
class A {
public:
void foo() {std::cout << "hi" << std::endl; };
};
void MakeA(A *pA) { pA = new A; }
From your question I think you understand that pA in main is not being
changed, that the pA in this function is a temporary and that after this
function is closed there is no way to delete the newed A.
int main() {
A* pA = NULL;
Make(pA);
pA->foo();
pA points to NULL still. Now, why does pA->foo(); work? It is undefined
behavior. However. Most compilers (if not all?) would actually convert
this to a call like:
foo( pA );
There is only one copy of the function A::foo() even if you have 100
instances of A. The hidden this pointer points to the instance of the
class, in this case NULL. Your function
void foo() {std::cout << "hi" << std::endl; };
does not attempt to dereference the this pointer (it does not try to access
any variables of the class) so for this undefined behavior you are getting
output. If you want to see different behavior for the exact same call, try
changing your class to:
class A {
public:
void foo() {std::cout << "hi" << i << std::endl; };
private:
int i;
};
and running the program and you should see a memory access violation reading
some location. That's because now the function is attempting to dereference
the this pointer, << i << becoming something like << this->i << which is
NULL plus some offset.
You can not count on undefined behavior, it is undefined. Sometimes you can
explain it however, but that doesn't mean you should count on it to always
work that way on different compilers or even the same compiler.
delete pA;
return 0;
}
And... why ((A*)NULL)->foo() works too?
Same as above. It becomes in the compiler foo( NULL );
Thanks in advance.
--
Jim Langston
tazmaster@rocketmail.com