c++智能指针使用笔记

1. c++智能指针中，c++的memory文件中，有auto_ptr等各种关于智能指针的东西，shared_ptr，weak_ptr在C++11中已经成为标准。

也看了ogs的智能指针，每次引用起来比较麻烦，规则也多。方便的是自动的引用计数，可选线程安全。

为方便 写了个公用类，如下：

#ifndef _test_share_ptr_h__
#define  _test_share_ptr_h__

#define  null 0
class  student
{
public:
	 student();
	 student(float score_)
		 :scores(score_)
	 {

	 }
	virtual ~ student();
public:
	char* all_class_name;
	float	scores;
private:

};

 student:: student()
{
}

 student::~ student()
{
	if (null != all_class_name)
	{
		delete []all_class_name;
		all_class_name = null;
	}
}

#endif

2.auto_ptr

功能相对简单，只能负责释加入到auto_ptr中的基类，并且基类中没有单独的到堆上申请内存。

写的两个函数测试，一个函数类：

void mem_ptr_student_new()
{
	int byte_numbers = 1024;
	for (int i = 0; i < count_times;i++)
	{
		student* pri_test_stu = new student;
		mem::auto_ptr<student> pri_student_share_ptr(pri_test_stu);
		pri_student_share_ptr->all_class_name = new char[byte_numbers];
		for (int j = 0; j < byte_numbers;j++)
		{
			pri_student_share_ptr->all_class_name[j] = j;
		}
		pri_student_share_ptr->scores = (float)(i + 10);
	}
}

typedef std::vector<mem::auto_ptr<student>> mem_vector_student;
void mem_ptr_student_vector_new()
{
	int byte_numbers = 1024;
	mem_vector_student pri_test_vector;
	/*

	mem::auto_ptr_ref<mem_vector_student> pri_auto_ref(&pri_test_vector);
	mem::auto_ptr<mem_vector_student> pri_vector_student_share_ptr(pri_auto_ref);
	for (int i = 0; i < count_times;i++)
	{
	mem::auto_ptr<student> pri_student_share_ptr(new student);
	pri_student_share_ptr->all_class_name = new char[byte_numbers];
	for (int j = 0; j < byte_numbers;j++)
	{
	pri_student_share_ptr->all_class_name[j] = j;
	}
	pri_student_share_ptr->scores = (float)(i + 10);
	pri_vector_student_share_ptr->push_back(pri_student_share_ptr);
	}*/
}

结果很明显，对于这样的类，char* all_class_name 在使用中自动申请了内存，auto_ptr很明显无能为力。内存泄露明显，所以第二个函数，stl vector的使用更不用多说，

一样不行。

摘抄了一段auto_ptr使用说明：

/*---------------------------mem_auto_ptr-------------------------------------*/
/*
 若下函数，使用mem::auto_ptr时候，不会自动调用student函数的析构，造成内存泄露。
 摘抄部分说明：

 * 1）auto_ptr不能共享所有权，即不要让两个auto_ptr指向同一个对象。
 * 

 *   2）auto_ptr不能指向数组，因为auto_ptr在析构的时候只是调用delete,而数组应该要调用delete[]。
 * 

 *   3）auto_ptr只是一种简单的智能指针，如有特殊需求，需要使用其他智能指针，比如share_ptr。
 * 

 *   4）auto_ptr不能作为容器对象，STL容器中的元素经常要支持拷贝，赋值等操作，在这过程中auto_ptr会传递所有权，那么source与sink元素之间就不等价。
*/

3.  别人写的一个share_ptr,用来测试和比较说明。

此类功能复杂，代码相对多。不过，挺好用。

若有问题，随时联系，可删除。

#ifndef __smart_shared_ptr_h__
#define __smart_shared_ptr_h__

#define  null 0
namespace smart
{
	class shared_ptr_reference_count
	{
	public:
		shared_ptr_reference_count()
		{
			_reference_count = 1;
		}

		virtual ~shared_ptr_reference_count()
		{
		}

		void grab()
		{
			_reference_count++;
		}

		size_t drop()
		{
			_reference_count--;
			return _reference_count;
		}

		size_t get_reference_count()
		{
			return _reference_count;
		}
	private:
		size_t _reference_count;
	};

	class shared_ptr_reference_destory
	{
	public:
		virtual ~shared_ptr_reference_destory(){};
	};

	template<class t>
	class smart_shared_ptr;

	class smart_shared_ptr_shadow
	{
	public:
		smart_shared_ptr_shadow()
			: _reference_instance(null)
			, _reference_count(null)
			, _reference_destory(null)
		{
		}

		smart_shared_ptr_shadow(void *instance_, shared_ptr_reference_count* reference_count_,  shared_ptr_reference_destory* reference_destory_)
			: _reference_instance(instance_)
			, _reference_count(reference_count_)
			, _reference_destory(reference_destory_)
		{
			if(_reference_count != null)
			{
				_reference_count->grab();
			}
		}

		~smart_shared_ptr_shadow()
		{
			if(_reference_count == null)
			{
				return;
			}

			if(_reference_count->drop() == 0){
				delete _reference_destory;
				_reference_destory = null;

				delete _reference_count;
				_reference_count = null;
			}
		}

		smart_shared_ptr_shadow(const smart_shared_ptr_shadow& right_)
		{
			if(right_._reference_count != null){
				right_._reference_count->grab();
			}

			_reference_instance = right_._reference_instance;
			_reference_count = right_._reference_count;
			_reference_destory = right_._reference_destory;
		}

		template<class t_>
		smart_shared_ptr<t_> to_shared_ptr()
		{
			return smart_shared_ptr<t_>((t_*)_reference_instance, _reference_count);
		}

		template<class t_>
		operator smart_shared_ptr<t_>()
		{
			return to_shared_ptr<t_>();
		}

		smart_shared_ptr_shadow& operator = (const smart_shared_ptr_shadow& right_)
		{
			if(right_._reference_count != null)
			{
				right_._reference_count->grab();
			}

			if(_reference_count != null)
			{
				if(_reference_count->drop() == 0)
				{
					delete _reference_destory;
					_reference_destory = null;

					delete _reference_count;
					_reference_count = null;
				}
			}

			_reference_instance = right_._reference_instance;
			_reference_count = right_._reference_count;
			_reference_destory = right_._reference_destory;
			return *this;
		}

		bool operator == (const smart_shared_ptr_shadow& right_) const
		{
			return (_reference_instance == right_._reference_instance);
		}

		operator bool() const
		{
			return _reference_count != null;
		}
	private:
		void* _reference_instance;
		shared_ptr_reference_count* _reference_count;
		shared_ptr_reference_destory* _reference_destory;
	};

	template<class t>
	class smart_shared_ptr
	{
		class shared_ptr_reference_destory_impl
			: public shared_ptr_reference_destory
		{
		public:
			shared_ptr_reference_destory_impl(t* reference_instance_)
			{
				this->_reference_instance = reference_instance_;
			}

			virtual ~shared_ptr_reference_destory_impl()
			{
				delete _reference_instance;
			}
		private:
			t* _reference_instance;
		};

	public:
		smart_shared_ptr()
			: _reference_count(null)
			, _reference_instance(null)
		{

		}

		smart_shared_ptr(t* instance_)
			: _reference_count(new shared_ptr_reference_count)
			, _reference_instance(instance_)
		{
		}

		smart_shared_ptr(t* instance_, shared_ptr_reference_count* reference_count_)
			: _reference_count(reference_count_)
			, _reference_instance(instance_)
		{
			if(_reference_count != null)
			{
				_reference_count->grab();
			}
		}

		~smart_shared_ptr()
		{
			if(_reference_count == null)
			{
				return;
			}

			if(_reference_count->drop() == 0)
			{
				delete _reference_instance;
				_reference_instance = null;

				delete _reference_count;
				_reference_count = null;
			}
		}

		t* operator -> ()
		{
			return _reference_instance;
		}

		smart_shared_ptr(const smart_shared_ptr& right_)
		{
			if(right_._reference_count != null)
			{
				right_._reference_count->grab();
			}

			_reference_instance = right_._reference_instance;
			_reference_count = right_._reference_count;
		}

		smart_shared_ptr_shadow to_shared_ptr_shadow()
		{
			return smart_shared_ptr_shadow(_reference_instance, _reference_count, new shared_ptr_reference_destory_impl(_reference_instance));
		}

		template<class t_>
		smart_shared_ptr<t_> to_shared_ptr()
		{
			return smart_shared_ptr<t_>((t_*)_reference_instance, _reference_count);
		}

		template<class t_>
		operator smart_shared_ptr<t_>()
		{
			return to_shared_ptr<t_>();
		}

		operator smart_shared_ptr_shadow()
		{
			return to_shared_ptr_shadow();
		}

		smart_shared_ptr& operator = (const smart_shared_ptr& right_)
		{
			if(right_._reference_count != null)
			{
				right_._reference_count->grab();
			}

			if(_reference_count != null)
			{
				if(_reference_count->drop() == 0)
				{
					delete _reference_instance;
					_reference_instance = null;

					delete _reference_count;
					_reference_count = null;
				}
			}

			_reference_instance = right_._reference_instance;
			_reference_count = right_._reference_count;

			return *this;
		}

		template<class t_>
		bool operator == (const smart_shared_ptr& right_) const
		{
			return (_reference_instance == right_.reference_instance);
		}

		operator bool() const
		{
			return _reference_count != null;
		}

		bool is_null() const
		{
			return _reference_count != null;
		}
	private:
		shared_ptr_reference_count* _reference_count;
		t* _reference_instance;
	};

#endif

同样的测试代码，只是里面类名称改变一下。如下：

void smart_ptr_student_new()
{
	int byte_numbers = 1024;
	for (int i = 0; i < count_times;i++)
	{
		smart_shared_ptr<student> pri_student_share_ptr = new student;
		pri_student_share_ptr->all_class_name = new char[byte_numbers];
		for (int j = 0; j < byte_numbers;j++)
		{
			pri_student_share_ptr->all_class_name[j] = j;
		}
		pri_student_share_ptr->scores = (float)(i + 10);
	}
}

typedef std::vector<smart_shared_ptr<student>> vector_student;
void smart_ptr_student_vector_new()
{
	int byte_numbers = 1024;
	smart_shared_ptr<vector_student> pri_vector_student_share_ptr = new vector_student();
	for (int i = 0; i < count_times;i++)
	{
		smart_shared_ptr<student> pri_student_share_ptr = new student;
		pri_student_share_ptr->all_class_name = new char[byte_numbers];
		for (int j = 0; j < byte_numbers;j++)
		{
			pri_student_share_ptr->all_class_name[j] = j;
		}
		pri_student_share_ptr->scores = (float)(i + 10);
		pri_vector_student_share_ptr->push_back(pri_student_share_ptr);
	}
}

结果：很明显，可管理类的对象指针和vector中的对象指针，因为重载了等号，括号，实时可以记录指针的使用次数，并处理了析构。计数的做为个类来处理，比有的智能

指针用个static的变量来好很多。

但是各种此类型的指针可以相互赋值，因为里面用的指针一律是void* 造成的。

3. 一个简单的ptr

不知道是否有问题啊。目前看起来还行。

#ifndef __m_smart_ptr_h__
#define  __m_smart_ptr_h__

#include <iostream>
#include <stdexcept>
using namespace std;

#define test_smart_ptr_cout
namespace s_smart
{
	template <typename T>
	class simple_smart_ptr
	{
	public:
		simple_smart_ptr(T *p = 0): ptr(p), p_use_count(new size_t(1))
		{
		}

		simple_smart_ptr(const simple_smart_ptr& src): ptr(src.ptr), p_use_count(src.p_use_count)
		{
			++*p_use_count;
		}

		simple_smart_ptr& operator= (const simple_smart_ptr& rhs) {
			// self-assigning is also right
			++*rhs.p_use_count;
			decrUse();
			ptr = rhs.ptr;
			p_use_count = rhs.p_use_count;
			return *this;
		}

		T *operator->()
		{
			if (ptr)
				return ptr;
			throw std::runtime_error("access through NULL pointer");
		}
		const T *operator->() const
		{
			if (ptr)
				return ptr;
			throw std::runtime_error("access through NULL pointer");
		}

		T &operator*()
		{
			if (ptr)
				return *ptr;
			throw std::runtime_error("dereference of NULL pointer");
		}

		const T &operator*() const
		{
			if (ptr)
				return *ptr;
			throw std::runtime_error("dereference of NULL pointer");
		} 

		~simple_smart_ptr()
		{
			decrUse();
#ifdef test_smart_ptr_cout
			std::cout<<"simple_smart_ptr: Destructor"<<std::endl; // for testing
#endif
		}

	private:
		void decrUse()
		{
			if (--*p_use_count == 0) {
				delete ptr;
				delete p_use_count;
			}
		}
		T *ptr;
		size_t *p_use_count;
	};
}

#endif

同样的测试过程，均可用。对类的指针有删除能力。

以上的智能指针的操作没有线程安全。

在osg的有一个宏定义来定义，是否启用原子操作的，_OSG_REFERENCED_USE_ATOMIC_OPERATIONS，对于计数的操作是安全的。

完结了！

本文代码下载地址：http://download.csdn.net/detail/cartzhang/7004199

形式是多种的，内容是一致的。

若有问题，请及时指正！