Is this strange behavior?

[Bo Yang]

Following is my code:

include <iostream>

class Test{
public:
Test(){};
void print(){ std::cout << "OK" << std::endl ; };
};

int main( int argc , char ** argv ){
Test * test = new Test();
Test r = *test ;

delete test ;
r.print(); //this line , this line
}

I think the comment line will produce an error.
But it output OK normally, is this behavior right?

[Markus Moll]

Hi

Bo Yang wrote:

int main( int argc , char ** argv ){
Test * test = new Test();
Test r = *test ;

delete test ;
r.print(); //this line , this line
}

I think the comment line will produce an error.
But it output OK normally, is this behavior right?

Absolutely, you call print on a copy of test that is still existent.

Markus

[Rud1ger Sch1erz]

Bo Yang <st******@mail. nankai.edu.cnwr ites:

int main( int argc , char ** argv ){
Test * test = new Test();
Test r = *test ;

delete test ;
r.print(); //this line , this line
}

I think the comment line will produce an error.

No.

But it output OK normally, is this behavior right?

Yes. r is a local variable (automatic), which is still in scope at
that line (actually in this block). It's not a copy of the pointer of
object test, but a copy of the value of test into its own memory.

Cheers,
Rudiger

[Mike Wahler]

"Bo Yang" <st******@mail. nankai.edu.cnwr ote in message
news:ek******** **@news.cn99.co m...

Following is my code:

include <iostream>

class Test{
public:
Test(){};
void print(){ std::cout << "OK" << std::endl ; };
};

int main( int argc , char ** argv ){
Test * test = new Test();
Test r = *test ;

delete test ;
r.print(); //this line , this line
}

I think the comment line will produce an error.

Why do you think so?

But it output OK normally, is this behavior right?

Yes, it is.

-Mike

[terminator]

Bo Yang wrote:

Following is my code:

include <iostream>

class Test{
public:
Test(){};
void print(){ std::cout << "OK" << std::endl ; };
};

int main( int argc , char ** argv ){
Test * test = new Test();
Test r = *test ;

delete test ;
r.print(); //this line , this line
}

I think the comment line will produce an error.
But it output OK normally, is this behavior right?

It IS correct .the compiler tries to make a copy constructor for every
class if you dont provide one.You did produce a default constructor but
u did not provide a copy constructor.

cheers
FM

[Salt_Peter]

Bo Yang wrote:

Following is my code:

include <iostream>

class Test{
public:
Test(){};

loose the extra semicolons - Test() { } is not a declaration only

void print(){ std::cout << "OK" << std::endl ; };

void print() const { std::cout << "OK" << std::endl ; }

};

int main( int argc , char ** argv ){
Test * test = new Test();

Test* test = new Test;

Test r = *test ;

delete test ;
r.print(); //this line , this line
}

I think the comment line will produce an error.

No it won't. The following statement:
Test r = *test ;
invokes a copy constructor.
The variable r is therefore allocated on the stack and survives until
the end of main's scope.

But it output OK normally, is this behavior right?

Yes, r is an independant variable.

Also, when you are testing for undefined behaviour, stick a dummy
variable in the class and test by attempting to access the dummy.

example:

#include <iostream>

class Test {
int n;
public:
Test() : n( 0 ) { }
int get() const {
return n;
}
void print() const {
std::cout << "OK\n";
}
};

int main() {
Test * p_test = 0; // pointer to a black hole
p_test->print(); // passes
// p_test->get(); // fails
}

[Erik Wikström]

On 2006-11-29 20:25, Salt_Peter wrote:

Also, when you are testing for undefined behaviour, stick a dummy
variable in the class and test by attempting to access the dummy.

example:

#include <iostream>

class Test {
int n;
public:
Test() : n( 0 ) { }
int get() const {
return n;
}
void print() const {
std::cout << "OK\n";
}
};

int main() {
Test * p_test = 0; // pointer to a black hole
p_test->print(); // passes
// p_test->get(); // fails
}

A question: I can understand why it works even if p_test == 0, but
should it work (is it legal)?
--
Erik Wikström

[peter koch]

Salt_Peter skrev:

Bo Yang wrote:

[snip]

int main() {
Test * p_test = 0; // pointer to a black hole
p_test->print(); // passes

Well... it passes in some sense of the word, surely. But it is
undefined behaviour and the statement there is not required to do
anything sensible. It might "work", it might abort the program and it
might send a rude email to your boss.
/Peter

// p_test->get(); // fails
}

[Puppet_Sock]

Salt_Peter wrote:
[snip]

Also, when you are testing for undefined behaviour, stick a dummy
variable in the class and test by attempting to access the dummy.

example:

#include <iostream>

class Test {
int n;
public:
Test() : n( 0 ) { }
int get() const {
return n;
}
void print() const {
std::cout << "OK\n";
}
};

int main() {
Test * p_test = 0; // pointer to a black hole
p_test->print(); // passes

What does the standard say should happen when you do this?
Personally, I would make a serious effort never to do -on a
null pointer, even if it's to a function with no access to data.

// p_test->get(); // fails
}

Socks

[Salt_Peter]

Erik Wikström wrote:

On 2006-11-29 20:25, Salt_Peter wrote:

Also, when you are testing for undefined behaviour, stick a dummy
variable in the class and test by attempting to access the dummy.

example:

#include <iostream>

class Test {
int n;
public:
Test() : n( 0 ) { }
int get() const {
return n;
}
void print() const {
std::cout << "OK\n";
}
};

int main() {
Test * p_test = 0; // pointer to a black hole
p_test->print(); // passes
// p_test->get(); // fails
}

A question: I can understand why it works even if p_test == 0, but
should it work (is it legal)?

Its *not* legal. Even if it appears to work. Thats my point.
The code you presented earlier does not invoke undefined behaviour. To
prove it, use get() as described in above.
A runtime error will not occur unless you attempt to access the invalid
object. So you can use something like get() to test for UB while
print() will erroneously fail to generate any error.