C++中智能指针的实现
C++中的智能指针是用一个类对另一个对象的指针或者引用进行管理，具体对该类的管理可以用包含对象指针以及引用计数的类来记录；
一般有两种方式实现：
1. 在对象内部记录引用的个数，这需要对象预留引用计数相关的接口
2. 用一个单独的资源管理类进行管理，则不需要修改对象
下面主要是第二种方法：（参考）http://blog.csdn.net/hackbuteer1/article/details/7561235
智能指针类将一个计数器与类指向的对象相关联，引用计数跟踪该类有多少个对象共享同一指针。每次创建类的新对象时，初始化指针并将引用计数置为1；当对象作为另一对象的副本而创建时，拷贝构造函数拷贝指针并增加与之相应的引用计数；对一个对象进行赋值时，赋值操作符减少左操作数所指对象的引用计数（如果引用计数为减至0，则删除对象），并增加右操作数所指对象的引用计数；调用析构函数时，构造函数减少引用计数（如果引用计数减至0，则删除基础对象）。
#include<iostream>
using namespace std;
// 定义仅由HasPtr类使用的U_Ptr类，用于封装使用计数和相关指针
// 这个类的所有成员都是private，我们不希望普通用户使用U_Ptr类，所以它没有任何public成员
// 将HasPtr类设置为友元，使其成员可以访问U_Ptr的成员
class U_Ptr
{
friend class HasPtr;
int *ip;
size_t use;
U_Ptr(int *p) : ip(p) , use(1)
{
cout << "U_ptr constructor called !" << endl;
}
~U_Ptr()
{
delete ip;
cout << "U_ptr distructor called !" << endl;
}
};
class HasPtr
{
public:
// 构造函数：p是指向已经动态创建的int对象指针
HasPtr(int *p, int i) : ptr(new U_Ptr(p)) , val(i)
{
cout << "HasPtr constructor called ! " << "use = " << ptr->use << endl;
}
// 复制构造函数：复制成员并将使用计数加1
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&);
// 析构函数：如果计数为0，则删除U_Ptr对象
~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) const
{
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; //指向使用计数类U_Ptr
int val;
};
HasPtr& HasPtr::operator = (const HasPtr &rhs) //注意，这里赋值操作符在减少做操作数的使用计数之前使rhs的使用技术加1，从而防止自我赋值
{
// 增加右操作数中的使用计数
++rhs.ptr->use;
// 将左操作数对象的使用计数减1，若该对象的使用计数减至0，则删除该对象
if (--ptr->use == 0)
delete ptr;
ptr = rhs.ptr; // 复制U_Ptr指针
val = rhs.val; // 复制int成员
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;
int *p2 = new int(56);
HasPtr *ka = new HasPtr(p2,57);
cout<<ka->get_ptr_val()<<" "<<ka->get_ptr_val()<<endl;
return 0;
}
更简单的实现：仅对一个对象进行管理
存在的问题： 没有理解智能指针的本质，用static 变量来保存所生成该对象引用的个数，会导致对无法对别的对象进行管理。（如果新生成一个资源对象，则static变量并不会归1，另外资源管理类赋值或者拷贝构造函数是对对象的拷贝或者赋值，而不是引用。 今天犯了一个大错误，this是当前对象的指针，要引用其成员变量，需要用->,最近编写java多了，C中指针基本操作给忘了）
#include <iostream>
using namespace std;
class Book {
public:
Book(int no):no(no){
}
void test(){
cout<<no<<endl;
}
~Book(){
cout<<"~Book"<<endl;
}
private:
int no;
};
class SmartPtr {
public:
static int cnt;
SmartPtr(){
}
SmartPtr(Book *t){
this->t = t;
cnt++;
}
SmartPtr( SmartPtr &rhs){
rhs.cnt++;
this->t = rhs.t;
}
SmartPtr(SmartPtr * rhs){
rhs->cnt++;
t = rhs->t;
}
SmartPtr operator=(const SmartPtr &rhs){
if(this==&rhs) {
return *this;
}
rhs.cnt++;
this->t = rhs.t;
return *this;
}
Book operator*(){
return *t;
}
Book * operator->(){
return t;
}
~SmartPtr() {
cout<<"enter the descrutor:"<< cnt<<endl;
if(--cnt == 0) {
delete t;
}
cout<<cnt<<endl;
}
private:
Book * t;
};
int SmartPtr::cnt = 0;
int main(){
Book *b1 = new Book(3);
SmartPtr *sp1 = new SmartPtr(b1);
SmartPtr *sp2 = new SmartPtr(sp1);
SmartPtr *sp3 = new SmartPtr(sp1);
(*sp3)->test();
delete sp3;
delete sp2;
delete sp1;
return 0;
}
改进实现： 引用计数类单独对内存进行管理；
UseCount.h
- class UseCount
- {
- friend class Handler;
- public:
- UseCount(void):p(new int(1)) //一个资源的计数初始化只生成一份，然后拷贝和赋值同时管理
- {
- }
- ~UseCount(void)
- {
- if(--*p == 0 ) {
- delete p;
- }
- }
- UseCount(const UseCount& rhs):p(rhs.p){
- ++*rhs.p;
- }
- UseCount & operator=(const UseCount & rhs){
- ++*rhs.p;
- if(--*p == 0){
- delete p;
- }
- p = rhs.p;
- }
- bool only(){
- return *p == 1;
- }
- private:
- int *p;
- };
Handler.h 负责对资源管理
- class Handler
- {
- public:
- ~Handler(void){
- if(u.only()) {
- delete p;
- } else {
- std::cout<< "jjj" << endl;
- }
- }
- Handler(const Point & point):p(new Point(point)) //资源仅生成一份
- {
- }
- Handler(const Handler &h):p(h.p),u(h.u){
- }
- Handler & operator=(const Handler &h){
- p = h.p;
- u = h.u;
- return *this;
- }
- private:
- Point *p;
- UseCount u;
- };
Point.h
- #pragma once
- class Point
- {
- public:
- Point(void){
- }
- ~Point(void){
- }
- };
main.cpp
- #include <iostream>
- #include "Handler.h"
- #include "Point.h"
- using namespace std;
- int main() {
- Point p;
- Handler h1(p);
- Handler* h2 = new Handler(h1);
- Handler* h3 = new Handler(h1);
- delete h3;
- delete h2;
- Point p1;
- Handler j1(p1);
- getchar();
- return 0;
- }
