Destructor Question

Hi,

From 11.11 here, I know that member objects get their dtor's called autmatically:

http://www.parashift.com/c++-faq-lit...html#faq-11.11

What if I have a pointer to a member object?

e.g. (in C++)

struct node
{
~node();

node * next;
}

node::~node()
{
cout << "Should this show once or a ton of times, for a linked list?" << endl;
}

Or inside the dtor, should I be doing this?

node::~node()
{
delete next;
}

Thanks!

[Alf P. Steinbach]

* dontspam@_dylan_.gov:

Hi,

From 11.11 here, I know that member objects get their dtor's called autmatically:

http://www.parashift.com/c++-faq-lit...html#faq-11.11

What if I have a pointer to a member object?
It doesn't matter if you have a pointer to an object or not.

The destructor is called when the object (not the pointer) is destroyed.

If you have allocated an object via

p = new SomeType;

then the object (not the pointer) is destroyed when you do

delete p;

and since the object is destroyed, its destructor is called.
e.g. (in C++)

struct node
{
~node();

node * next;
}
Missing semicolon.

node::~node()
{
cout << "Should this show once or a ton of times, for a linked list?" << endl;
}

Or inside the dtor, should I be doing this?

node::~node()
{
delete next;
}

Probably neither, but what to do depends -- obviously -- on what you
want to achieve.

If it is your intent that a message should be output on std::cout
whenever a node object is destroyed, do the first. That will make the
node class unusable in a program with a graphical user interface, and in
general, it will make the class unusable for any other purpose than the
original context. So in general, don't do i/o in classes not
specifically designed to do i/o, and in general, don't mix unrelated
things but instead separate them.

If it is your intent that whenever a node object is destroyed it should
also destroy all objects linked via its next pointer, do the second.
That will also constrain the usage of node objects. It seems to belong
at a higher level of abstraction than node does.

--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?

[NoS_Pam]

I think the point of my question was not seen.

11.11 here states that member objects have their destructors called when
the object itself is deleted (follow this link please!).

http://www.parashift.com/c++-faq-lit...html#faq-11.11

Now, a more detailed code segment (complete with semicolon!).

struct node
{
~node();

node * next;
};

// Say I have a linked list, where the root node is "node * list".

// What does the following do?
delete list;

// Assuming node::~node() is implemented as follows:
node::~node() {} // (Empty)
Does it delete the root node only? Or recursively delete all node's by
calling the destructor's for all the next's? ("next->~node()").

To test this, I make a long linked list, and make the destructor
definition as follows:
node::~node() { cout << "HELLO!" << endl; }

Then I used "delete list;". Sure enough, "HELLO!" was repeated a bunch of
times. This was unexpected to me, I didn't think a destructor
automatically called member object pointer's destructors automatically. I
don't think it mentions anything about it in the C++ FAQ lite.

So, I am running it by the group.
Let me know if that's the expected behavior,
Thanks!


"Alf P. Steinbach" <al***@start.no> wrote in
news:45************@individual.net:

* dontspam@_dylan_.gov:

Hi,

From 11.11 here, I know that member objects get their dtor's called
autmatically:

http://www.parashift.com/c++-faq-lit...html#faq-11.11

What if I have a pointer to a member object?

It doesn't matter if you have a pointer to an object or not.

The destructor is called when the object (not the pointer) is
destroyed.

If you have allocated an object via

p = new SomeType;

then the object (not the pointer) is destroyed when you do

delete p;

and since the object is destroyed, its destructor is called.

e.g. (in C++)

struct node
{
~node();

node * next;
}

Missing semicolon.

node::~node()
{
cout << "Should this show once or a ton of times, for a linked
list?" << endl;
}

Or inside the dtor, should I be doing this?

node::~node()
{
delete next;
}

Probably neither, but what to do depends -- obviously -- on what
you want to achieve.

If it is your intent that a message should be output on std::cout
whenever a node object is destroyed, do the first. That will make the
node class unusable in a program with a graphical user interface, and
in general, it will make the class unusable for any other purpose than
the original context. So in general, don't do i/o in classes not
specifically designed to do i/o, and in general, don't mix unrelated
things but instead separate them.

If it is your intent that whenever a node object is destroyed it
should also destroy all objects linked via its next pointer, do the
second. That will also constrain the usage of node objects. It seems
to belong at a higher level of abstraction than node does.

[Alf P. Steinbach]

* NoS_Pam:

[top-posting]
[excessive quoting]
Please don't top-post (corrected). Please don't quote excessively
(corrected). Please read the FAQ (which you have found, good).
* NoS_Pam: * Alf P. Steinbach:

* dontspam@_dylan_.gov:

[question]
[answer]

I think the point of my question was not seen.

It was.
[snip] Now, a more detailed code segment (complete with semicolon!).

struct node
{
~node();

node * next;
};

// Say I have a linked list, where the root node is "node * list".

// What does the following do?
delete list;
It destroys the root node. The root node's destructor is thereby invoked.

// Assuming node::~node() is implemented as follows:
node::~node() {} // (Empty)
In that case only the root node is destroyed and nothing else happens.

Does it delete the root node only?
Yes.

Or recursively delete all node's by
calling the destructor's for all the next's? ("next->~node()").
No.

To test this, I make a long linked list, and make the destructor
definition as follows:
node::~node() { cout << "HELLO!" << endl; }

Then I used "delete list;". Sure enough, "HELLO!" was repeated a bunch of
times.
Human error. Probably you ran an old version of the program.

This was unexpected to me, I didn't think a destructor
automatically called member object pointer's destructors automatically.
It doesn't.

I don't think it mentions anything about it in the C++ FAQ lite.
It does, you have linked to the relevant pages yourself.

So, I am running it by the group.
For the second time now.

Let me know if that's the expected behavior,

With human error involved, anything can happen.
--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?

[Mike Wahler]

"NoS_Pam" <dontspam@_dylan_.gov> wrote in message
news:Xn******************@130.215.36.210...

I think the point of my question was not seen.

11.11 here states that member objects have their destructors called when
the object itself is deleted (follow this link please!).

http://www.parashift.com/c++-faq-lit...html#faq-11.11

Now, a more detailed code segment (complete with semicolon!).

struct node
{
~node();

node * next;
};

// Say I have a linked list, where the root node is "node * list".
The declaration:

node *list;

Creates a type 'node *' object. It is not dynamically
allocated (with 'new'), so you must not try to 'delete' it.

// What does the following do?
delete list;
Undefined behavior.

// Assuming node::~node() is implemented as follows:
node::~node() {} // (Empty)
If it doesn't do anything, you need not define it
(the compiler will create it for you).


Does it delete the root node only?
If you 'delete' a pointer whose value was not
the return value from 'new', the behavior is
undefined.
Or recursively delete all node's by
calling the destructor's
When an object is destroyed (whether by going out
of scope or as a result of 'delete'), its destructor
is automatically invoked. A destructor does not
'delete' anything unless it contains code which
explicitly calls 'delete'.

for all the next's? ("next->~node()").
No.

To test this, I make a long linked list, and make the destructor
definition as follows:
node::~node() { cout << "HELLO!" << endl; }

Then I used "delete list;".
Show us the *exact* code you used.
Sure enough, "HELLO!" was repeated a bunch of
times.
It will be repeated for each time the destructor is
called. It doesn't matter whether its called because
the object was 'delete'd or simply went out of scope.
This was unexpected to me, I didn't think a destructor
automatically called member object pointer's destructors automatically.
A destructor will only do what the code inside it tells
it to do.
I
don't think it mentions anything about it in the C++ FAQ lite.

Because that's not how destructors work.

-Mike

[Daniel T.]

In article <Xn******************@130.215.36.210>,
"NoS_Pam" <dontspam@_dylan_.gov> wrote:

I think the point of my question was not seen.

11.11 here states that member objects have their destructors called when
the object itself is deleted (follow this link please!).

http://www.parashift.com/c++-faq-lit...html#faq-11.11

Now, a more detailed code segment (complete with semicolon!).

struct node
{
~node();

node * next;
};

// Say I have a linked list, where the root node is "node * list".

// What does the following do?
delete list;

// Assuming node::~node() is implemented as follows:
node::~node() {} // (Empty)
Does it delete the root node only? Or recursively delete all node's by
calling the destructor's for all the next's? ("next->~node()").

To test this, I make a long linked list, and make the destructor
definition as follows:
node::~node() { cout << "HELLO!" << endl; }

Then I used "delete list;". Sure enough, "HELLO!" was repeated a bunch of
times. This was unexpected to me, I didn't think a destructor
automatically called member object pointer's destructors automatically. I
don't think it mentions anything about it in the C++ FAQ lite.

So, I am running it by the group.
Let me know if that's the expected behavior,

Given this code:

class A {
public:
~A() { cout << "A::~A()\n"; }
};

class B {
A* a;
public:
B( A* anA ): a( anA ) { }
~B() { cout << "B::~B()\n"; }
};

int main() {
A* a( new A );
B* b( new B( a ) );
delete b;
cout << "is A dead?\n";
delete a;
}

The output should be:
B::~B()
is A dead?
A::~A()

Which of course means that B::~B() did not delete it's 'a' object.
Hope this helps.

--
Magic depends on tradition and belief. It does not welcome observation,
nor does it profit by experiment. On the other hand, science is based
on experience; it is open to correction by observation and experiment.

[Viru Rathore]

Hi
Here 'a' is pointer of class A in class B so whenever you are not call
delete on 'a' that 'a' is not deleted.

object is called the destructor not the pointer itself.

[Viru Rathore]

Hi
next is pointer if you have not assign a object address that pointer
and delete that pointer that case you got the exception or crash your
application.
first when your constructor should called that assign NULL value to
next.
and in destructor you should code this
if(next) delete next;
otherwise you got the exception.

and one thing you should try so you can better understood.
sturct node{
node next;
};
compile this and check the information given by compiler.

if i am wrong then reply where i am wrong so i can improve my self.