[C++]智能指针

#include <iostream>
using namespace std;
class U_ptr {
private:
friend class HasPtr;
int *ip;
size_t use;
U_ptr(int *p) : ip(p), use(1) {};
~U_ptr() {
delete ip;
}
};

class HasPtr {
public:
// 定义复制控制操作
HasPtr(int *p, int i) : ptr(new U_ptr(p)), val(i) {
cout << "HasPtr constructor called ! " << "use = " << ptr->use << endl;
}
HasPtr(const HasPtr &orig) :
ptr(orig.ptr), val(orig.val) {
++ptr->use;
cout << "HasPtr copy constructor called ! " << "use = " << ptr->use << endl;
}
HasPtr& operator=(const HasPtr &orig);
~HasPtr() {
cout << "HasPtr distructor called ! " << "use = " << ptr->use << 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 get_ptr_val() const {
return *ptr->ip;
}
void set_ptr_val(int i) const {
*ptr->ip = i;
}

private:
U_ptr *ptr;
int val;
};

HasPtr& HasPtr::operator=(const HasPtr &orig) {
++orig.ptr->use;
if (--ptr->use == 0) {
delete ptr;
}
ptr = orig.ptr;
val = orig.val;
return *this;
}

int main(void)
{
int *pi = new int(42);
HasPtr *hpa = new HasPtr(pi, 100);    // 构造函数
HasPtr *hpb = new HasPtr(*hpa);     // 拷贝构造函数
HasPtr *hpc = new HasPtr(*hpb);     // 拷贝构造函数
HasPtr hpd = *hpa;     // 拷贝构造函数

cout << hpa->get_ptr_val() << " " << hpb->get_ptr_val() << endl;
hpc->set_ptr_val(10000);
cout << hpa->get_ptr_val() << " " << hpb->get_ptr_val() << endl;
hpd.set_ptr_val(10);
cout << hpa->get_ptr_val() << " " << hpb->get_ptr_val() << endl;
delete hpa;
delete hpb;
delete hpc;
cout << hpd.get_ptr_val() << endl;
return 0;
}

// 定义值型类
#include <iostream>
using namespace std;
class Has_Ptr {
public:
Has_Ptr(const int &p, int i) : ptr(new int(p)), val(i) {}
Has_Ptr(const Has_Ptr &orig) :
ptr(new int (*orig.ptr)), val(orig.val) {}
Has_Ptr& operator=(const Has_Ptr&);
~Has_Ptr() {
delete ptr;
}
int get_ptr_val() const {
return *ptr;
}
int get_int() const {
return val;
}
void set_ptr(int *p) {
ptr = p;
}
void set_int(int i) {
val = i;
}
int *get_ptr() const {
return ptr;
}
void set_ptr_val(int p) const {
*ptr = p;
}
private:
int *ptr;
int val;
};
Has_Ptr& Has_Ptr::operator=(const Has_Ptr &orig) {
*ptr = *orig.ptr;
val = orig.val;
return *this;
}

int main() {
int *p = new int(42);
Has_Ptr hpd(*p, 10);
Has_Ptr hpa(hpd);
int *h = new int(20);
Has_Ptr hpc(*h, 29);
hpd = hpc;
cout << hpa.get_int() << endl;
cout << hpd.get_ptr_val() << endl;
return 0;
}