一个可以放入STL容器的简洁、高效、非计数的智能指针实现

只要学过C++的都知道STL内有一个auto_ptr的智能指针实现，可惜的很这个智能指针和STL容器格格不入，无法和像vector、list、deque、map、set等这样关键性的容器配合使用，大大降低了auto_ptr的使用范围和应用范畴。至于boost库内倒是有share_ptr和weak_ptr这样的智能指针，但是boost库并非标准库，且实现比较复杂不比auto_ptr实现简单。为此我想和很多，难道真的没有一个简单的可以放置到容器内高效的的智能指针呢？最近有机会我终于实现了一个这样一个智能指针。其原理如下：

首先，吸取auto_ptr的教训，将内存管理的句柄分为两个。一个负责持有对象，在必要时释放所持有的对象所占的空间。另一个则是负责供外面的用户使用，即使所持有的对象转移了依然不影响对源对象的使用。

接着，吸取auto_ptr之所以高效的经验，采用持有对象转移策略。

然后，将管理对象分治为管理一个对象和管理多个对象的方略，分别提供不同实现方法和操作以便更进一步降低复杂度。

最后，将接口最小化，紧守本有功能，不提供额外功能，但是在力所能及的情况下提供足够便利的高效的功能。

其具体实现代码如下：

////auto_pointer.h

#ifndef __AUTO_POINTER_H__

#define __AUTO_POINTER_H__

//#include "debug_log.h"

#include <cassert>

////用于代替std::auto_ptr，其接口设计与其保持兼容，用于管理单个对象

template <typename T>

class auto_pointer

{

public:

typedef T element_type;

public:

////为了兼容原来的auto_ptr, 缺省构造函数

auto_pointer() throw()

: m_uPtr(0)

, m_aPtr(0)

{

}

////为了兼容原来的auto_ptr，单参数构造

auto_pointer(element_type *p) throw()

: m_uPtr(p)

, m_aPtr(p)

{

}

////复制构造函数

////一个本类对象传过来，接收方保存其对象的句柄值，源对象不再负责释放其对象句柄

auto_pointer(const auto_pointer<element_type>& ref) throw()

: m_uPtr(release(&ref))

, m_aPtr(m_uPtr)

{

}

~auto_pointer() throw()

{

reset(0);

}

auto_pointer<element_type>& operator =(const auto_pointer<element_type>& ref) throw()

{

reset(release(&ref));

return *this;

}

const element_type& operator *() const throw()

{

assert(m_uPtr != 0);

return *m_uPtr;

}

element_type& operator *() throw()

{

assert(m_uPtr != 0);

return *m_uPtr;

}

const element_type* operator->() const throw()

{

return m_uPtr;

}

element_type* operator->() throw()

{

return m_uPtr;

}

element_type* get() const throw()

{

return m_uPtr;

}

const element_type* get() throw()

{

return m_uPtr;

}

void reset(element_type *p) throw()

{

if (m_aPtr)

{

//DEBUG_LOG("auto_pointer delete");

delete m_aPtr;

}

m_uPtr = m_aPtr = p;

}

element_type *release() throw()

{

return release(this);

}

private:

////将源对象的持有句柄置空，返回源对象的使用句柄

static element_type *release(const auto_pointer<element_type> *ref) throw()

{

auto_pointer<element_type> *p = (const_cast< auto_pointer<element_type> *>(ref));

p->m_aPtr = 0;

return p->m_uPtr;

}

private:

element_type* m_uPtr;

element_type* m_aPtr;

};

template <>

class auto_pointer<void>

{

public:

typedef void element_type;

};

////自动缓冲区类，是auto_pointer的多个对象版

template <typename T>

class auto_buffer

{

public:

typedef unsigned int size_t;

typedef T element_type;

public:

////缺省构造器

auto_buffer() throw()

: m_uPtr(0)

, m_aPtr(0)

{

}

////一般构造器

auto_buffer(element_type *p) throw()

: m_uPtr(p)

, m_aPtr(p)

{

}

////复制构造器

////一个本类对象传过来，接收方保存其对象的句柄值，源对象不再负责释放其对象句柄

auto_buffer(const auto_buffer<element_type>& ref) throw()

: m_uPtr(release(&ref))

, m_aPtr(m_uPtr)

{

}

////析构器

~auto_buffer() throw()

{

reset(0);

}

////复制操作符

auto_buffer<element_type>& operator =(const auto_buffer<element_type>& ref) throw()

{

reset(release(&ref), ref.m_size);

return *this;

}

element_type* get() throw()

{

return m_uPtr;

}

const element_type* get() const throw()

{

return m_uPtr;

}

void reset(element_type *p) throw()

{

if (m_aPtr)

{

//DEBUG_LOG("auto_buffer delete");

delete[] m_aPtr;

}

m_uPtr = m_aPtr = p;

}

element_type* release() throw()

{

return release(this);

}

private:

////将源对象的持有句柄置空，返回源对象的使用句柄

static

element_type* release(const auto_buffer<element_type> *ref) throw()

{

auto_buffer<element_type> *p = (const_cast< auto_buffer<element_type> *>(ref));

p->m_aPtr = 0;

return p->m_uPtr;

}

private:

element_type* m_uPtr;

element_type* m_aPtr;

};

template <>

class auto_buffer<void>

{

public:

typedef void element_type;

};

#endif

////end auto_pointer.h

////debug_log.h

#ifndef __DEBUG_LOG_H_

#define __DEBUG_LOG_H_

//#include <qstring.h>

void debug_log(const char *_s);

//inline void debug_log(const QString& _s)

//{

// debug_log(_s.toLocal8Bit().constData());

//}

#ifdef ENABLE_DEBUG_LOG

#define DEBUG_LOG(a) debug_log(a)

//#define DEBUG_LOG1(a) DEBUG_LOG(QString(# a ":%1").arg(a))

//#define DEBUG_LOG2(a, b) DEBUG_LOG(QString(# a ":%1 " # b ":%2").arg(a).arg(b))

#else

#define DEBUG_LOG(a)

//#define DEBUG_LOG1(a)

//#define DEBUG_LOG2(a, b)

#endif

#endif //__DEBUG_LOG_H_

////end debug_log.h

////debug_log.cpp

#include "debug_log.h"

#include <cstdio>

#include <string>

#include <ctime>

//#include <cstdarg>

const std::string now_time()

{

time_t _tim = time(0);

std::string _stim(ctime(&_tim));

return _stim.substr(0, _stim.size() - 1);

}

void debug_log(const char *s)

{

FILE *_out = fopen("c:/debug_log.log", "a+");

if (_out)

{

fprintf(_out, "%s %s\n", now_time().c_str(), s);

fclose(_out);

}

}

////end debug_log.cpp

////main.cpp

#include "auto_pointer.h"

#include <iostream>

#include <string>

#include <vector>

#include <cstdio>

struct a

{

a(int _base = 0, const std::string& _s = "")

: base(_base)

, s(_s)

{

}

int base;

std::string s;

};

std::string to_str(int _value)

{

char buffer[256] = {0};

sprintf(buffer, "%d", _value);

return buffer;

}

int main(int argc, char *argv[])

{

/*auto_pointer<int> ap1(new int(1978));

auto_pointer<int> ap2(new int);

*ap2 = 110;

std::cout << "ap1:" << *ap1 << ", ap2:" << *ap2 << std::endl;

ap2 = ap1;

std::cout << "ap1:" << *ap1 << ", ap2:" << *ap2 << std::endl;

auto_pointer<a> p1(new a(100, "wps"));

std::cout << "base:" << p1->base << ", s:" << p1->s << std::endl;

*/

/*typedef std::vector< auto_pointer<a> > ints_t;

ints_t va;

for (int i = 0; i < 100; ++i)

{

va.push_back(new a(i, to_str(i << 1)));

}

*/

typedef auto_buffer<int> ints_t;

ints_t v(new int[100]);

int i = 0;

for (int *begin = v.get(), *end = begin + 100; begin != end; ++begin)

{

*begin = i++;

}

//int i = 0;

for (const int *begin = v.get(), *end = begin + 100; begin != end; ++begin)

{

std::cout << *begin << std::endl;

//*begin = 123;

}

typedef std::vector< auto_buffer<int> > va_t;

va_t va;

for (int i = 0; i < 10; ++i)

{

auto_buffer<int> buf(new int[10]);

for (int *begin = buf.get(), *end = begin + 10; begin != end; ++begin)

{

*begin = i;

}

va.push_back(buf);

}

return 0;

}

////end main.cpp