析构函数的调用两次,这是为什么?

[panyf_2k]

#include<stdio.h>
#define TRACE printf

class RefCount
{
int crefs;
public:
RefCount(void) { crefs=0; }
~RefCount() { TRACE("goodbye(%d)\n",crefs); }
void upcount(void)
{
++crefs;
TRACE("up to %d\n",crefs);
}
void downcount(void)
{
if(--crefs==0)
delete this;
else
TRACE("downto %d\n",crefs);
}
};

class Sample:public RefCount
{
public:
void doSomething(){ TRACE("Did somthing\n");}
};

template<class T>
class Ptr
{
T* p;
public:
Ptr(T* p_):p(p_) { p->upcount(); }
~Ptr(void) { p->downcount(); }
operator T*(void) { return p; }
T& operator*(void) { return* p; }
T* operator->(void) { return p; }
Ptr& operator=(Ptr<T>& p_)
{
return operator=((T*)p_);
}
Ptr& operator=(T* p_)
{
p->downcount();
p=p_;
p->upcount();
return* this;
}
};

void main()
{
Ptr<Sample> p=new Sample;
Ptr<Sample> p2=new Sample;
p=p2;
p->doSomething();
}

针对上述程序我有两个疑问:
1.p_这个参数的值如何引入?
2.在main结束前调用两次析构函数?

[类库]

用了继承，就会调用子类后父类的析构函数。

[E]

1.p_这个参数的值如何引入？
Ptr<Sample> p=new Sample;的相当于：
Ptr<Sample> p(new Sample); //new Sample相当于p_
原理是：声明类实例时当等号右边的类型（此例中为Sample*）和等号左边的类型(Ptr<Sample>）不一致时，c++会以等号右边的变量为参数调用类（Ptr<Sample>）的构造函数。
2.在main结束前调用两次析构函数？
当然一个是为p调的，一个是为p2调的

[E]

1.p_这个参数的值如何引入？
Ptr<Sample> p=new Sample;的相当于：
Ptr<Sample> p(new Sample); //new Sample相当于p_
原理是：声明类实例时当等号右边的类（此例中为Sample*）和等号左边的类(Ptr<Sample>）不一致时，c++会以等号右边的变量为参数调用类左边类（Ptr<Sample>）的构造函数。
2.在main结束前调用两次析构函数？
当然，一个是为p调的，一个是为p2调的，有几个实例就调几次。

[panyf_2k]

难道就没人帮我解答??

[panyf_2k]

我明白了,感谢E()的认真解答!

[snwcwt]

得到解答了还不给人家分

[heavyrain1234]

right

[panyf_2k]

请问snwcwt,如何给人家分?怎么操作!