Re: why does this call the destructor?
"michael" <spam@begone.net> wrote in message
news:463acef6$0$17194$5a62ac22@per-qv1-newsreader-01.iinet.net.au...
Hi All,
I have written the following to illustrate a problem.
I know I have some magic numbers etc please ignore them.
What I do not follow is why the line marked results in a call to the
destructor for the object.
Can someone please explain it for me?
#include <iostream>
#include <fstream>
using std::ostream;
class someClass {
private:
char *str;
public:
someClass();
~someClass();
friend ostream& operator <<(ostream& lhs, someClass rhs);
};
someClass::someClass(){
str = new char[10];
strcpy(str, "something");
}
someClass::~someClass(){
std::cout << "\nIn someClass destructor...\n";
delete str;
}
ostream& operator <<(ostream& lhs, someClass rhs){
lhs << rhs.str; // This results in a call to the destructor for
the someClass object....why?
return lhs;
}
int main(){
someClass soc;
std::cout << soc;
}
Thanks for your help
(I actually wanted to reply to your later post but anon snipped out too much
of the message).
The class still exists. The problem is you didn't follow the rule of 3. In
a nutshell: A class with any of {destructor, assignment operator, copy
constructor} generally needs all 3
The problem is that your class is being copied by the operator<< function,
and the copy is being deleted when the function ends. But your destructor
deletes your str char*. Which points to your original str* so it is the one
getting deleted, and your orignal becomes corrupt.
This is where the rule of three comes in. Since you need a destructor,
you'll need an assigment operator and copy constructor to go along with it.
In your copy constructor you could allocate memory for the copy of str, then
strcpy the value in.
Myself, when I find that I need a destructor I right away make a copy
constructor and an assignment operator private to the class with no code.
Since they're private, they can't be called. Usually when I find myself
allocating memory in a class I don't WANT the classs to ever be copied (but
that's just me). If I find that, actually, yes, I want to be able to copy
this class, then I will go ahead and correctly code the copy and assignment
operators.
Just add this to your class and try to compile and you'll see the problems:
private:
// No copy or assignment yet so disable by making private.
someClass ( someClass const& /*CopyThis*/ ) { } // Copy constructor.
someClass& operator=( someClass const& /*CopyThis*/ ) { } // Assignment.
now try to compile your code. Everywhere you get an error stating there is
no public copy or assignment operator would of been a bug in your program.
Either change your code so you don't have to make copies (pass references
instead of by value, etc...) or correctly code the copy constructor and
assignment operator so the copies have their own copy of str which they can
delete with inpunity.