关于C++智能指针的

首先附上代码
具体我想问的问题在main函数注释中我已经提出来了



#include <iostream>
using namespace std;

class U_Ptr //引用计数类
{
friend class HasPtr;
int *ip;
size_t use;
U_Ptr(int *p):ip(p),use(1){cout<<"U_ptr构造函数"<<endl;}
~U_Ptr()
{
cout<<"U_ptr的析构函数"<<endl;
delete ip;
}
};

class HasPtr //实际类
{
public:
HasPtr(int *p,int i):ptr(new U_Ptr(p)),val(i){cout<<"HasPtr构造函数"<<endl;}
HasPtr(const HasPtr& orig):ptr(orig.ptr),val(orig.val) 
{
++ptr->use;
cout<<"HasPtr拷贝构造函数"<<endl;
}
HasPtr& operator=(const HasPtr&);
~HasPtr() 
{
cout<<"HasPtr的析构函数"<<endl;
if(--ptr->use==0) 
delete ptr;
}

//获取数据成员
int* get_ptr() const {return ptr->ip;}
int get_int() const {return val;}

//修改数据成员
void set_ptr(int *p) {ptr->ip=p;}
void set_int(int i) {val=i;}

//返回或修改基础int对象
int get_ptr_val() const {return *ptr->ip;}
void set_ptr_val(int i) {*ptr->ip=i;}
private:
U_Ptr *ptr;
int val;
};

HasPtr & HasPtr::operator=(const HasPtr& rhs)
{
cout<<"HasPtr的赋值操作"<<endl;
++rhs.ptr->use; //增加右操作数的引用计数
if (--ptr->use==0)
{
delete ptr;
}
ptr=rhs.ptr;
val=rhs.val;

return *this;
}

void main()
{
/*int temp=50;
int *obj=&temp; */ //为什么用这种方式，在调用析构函数的时候会崩溃？
int *obj=new int(50); //这种方式却不会崩溃？
HasPtr has(obj,20);
}

new delete是对应的吧
new分配在堆中，常量50应该在数据区中

temp不是动态创建的变量，不需要，也不可以编辑特定的代码进行析构，否则会引起内存分配问题，很严重！

你自己看U_Ptr的析构函数嘛
~U_Ptr()
 {
 cout<<"U_ptr的析构函数"<<endl;
 delete ip;
 }

最后一步是将实际地址析构
你不是new出来的是不可以delete的

temp是对象变量，会在退出函数时自动释放，如果你在之前进行delete动作，就会有两次释放动作，引起崩溃。