I don't understand...

a simple example destructor,i really donot understand the output

Code:

#include<iostream>
using namespace std;

class T {
public:
	T( double d ) : pd( new double( d ) ) { };
	~T();
private:
	double *pd;
};
T::~T()
{
	cout << ( *pd ) << endl;
//	( *pd ) = -1;
//	delete pd;
}

extern void func( T t )
{
	/* ... */
	cout << " Here " << endl;
}

void main()
{
	T t( 1.2 );
	T t1( 1.8 );
	func( t );
	func( t1 );
}

the output is like this:
Here
1.2
Here
1.8
1.8
1.2

but in my opinion,it should be
Here
1.8
Here
1.2

so why? Could anyone explain it to me?
any help is appreciated...

It's right, here's the breakdown. btw this is a good example of why it's inefficient to pass by value. pass by reference would remove the first 1.8 and 1st 1.2, making the output
Here
Here
1.8
1.2

t constructed <- no output
t1 constructed <- no output
func(t) called <- copy of t made <- no output
Here <- function body outputs here
1.2 <- function ends, copy of t destructed, outputs 1.2
func(t1) called <- copy of t1 made <- no output
Here <- function body outputs here
1.8 <- function ends, copy of t1 destructed, outputs 1.8
1.8 <- main ends variables destructed in reverse order of creation
1.2 <- first t1, then t

got it！
thx very much

That code ought to crash, by the way, and it would if you hadn't commented out the two lines in the destructor. As it is, it has a memory leak.

It's a good example why classes with dynamic memory always need a copy constructor.

Originally Posted by CornedBee

That code ought to crash, by the way, and it would if you hadn't commented out the two lines in the destructor. As it is, it has a memory leak.

It's a good example why classes with dynamic memory always need a copy constructor.

You're correct, but I doubt the reasons would be obvious to beginners. You may wish to expand on your comments......

I might, but I think it would be easier (for me) if the poster just searched for the phrase "deleted twice".

an advice. Whenever you delete a pointer set it to null. You can use some templated function to do that automaticly for you always.

Code:

template<class Xptr> inline delete_ptr(Xptr*& p){
    delete p;
    p = NULL;
}
template<class Xptr> inline delete_array(Xptr*& p){
    delete[] p;
    p = NULL;
}

Wouldn't have helped in this case. It's two different pointers pointing to the same location he's deleting, so setting each to NULL after deleting them wouldn't change a thing.

So I've seen now.
Lorin, you have to define a copy constructor, and by the way the operator=(...)

>> Lorin, you have to define a copy constructor, and by the way the operator=(...)
or make them both private

or use smart pointers