在Symbian开发过程中, 由于没有确定性析构, 最让人烦躁的就是Cleanup Stack的操作, 当在一个函数中使用局部变量时,
要记得PushL, 然后在函数末尾, 还要PopAndDestroy, 变量一多, 头昏脑胀,都找不到北了, 经常被Panic, 而且在VC6窗口
中还不知道到底是哪行的问题, 只能单步调试, 一直到程序crash. 然后知道上一行就是问题所在.
下面是我写的一个智能指针类( 实际上是两个, 一个CPtr用于C class, 一个RPtr 用于R class), 我自己的使用经验表明可以免除90%的对Cleanup Stack的操作. (实际上我在新代码中从来不再手动使用CleanupStack了)
例如一个简单的代码:
void FunL()
{
HBufC * wbuf = HBufC::NewL(10);
CleanupStack::PushL(wbuf); //有点造作, 应该直接的用HBufC::NewLC, 仅仅是举个例子, 因为很多类只提供了NewL
HBufC * wbuf2 = HBufC::NewL(20);
CleanupStack::PushL(wbuf2);
RFs fs;
User::LeaveIfEror( fs.Connect());
CleanupClosePushL(fs);
do_sth_maybe_leaveLLL();
CleanupStack::PopAndDestroy(3); //关文件fs, 删除wbuf, wbuf2
}
如果函数中又增加一个C对象的使用, 那么要手动PushL一次, 然后在结尾还要记得将PopAndDestroy(3) 改为 4.
如果利用智能指针, 上面的代码可以简化为:
void FunL()
{
using namespace sbl; //封装在sbl中
CPtr<HBufC> wbuf(HBufC::NewL(10)); //永远不要调用NewLC, CPtr内部会PushL的
CPtr<HBufC> wbuf2(HBufC::NewL(20)); //同上
RPtr<RFs> fs;
User::LeaveIfEror( fs->Connect()); //fs.Connect() 改为 fs->Connect()
do_sth_maybe_leaveLLL();
}
以后就什么都不用管了, Leave也好, 不Leave也好, wbuf, wbuf2最终都会被delete, fs都会被关闭.
记住的是:
1. 不要对成员变量使用CPtr, RPtr (你应该知道, 成员变量本身就不应该PushL)
2. 在一个函数中不要混合使用CleanupStack 和 智能指针类. 要不你就手动的PushL, 要不就全部交给智能指针.
3. 在给CPtr智能指针初始化/赋值的时候, 永远不要调用Cxxx::NewLC, (因为NewLC自己PushL一次了), 而总是调用NewL.
另外, 有了智能指针, 基本上你无需再给你的class提供NewLC了, 而且NewL中的实现可以如下:
/* static */
CFoo * CFoo::NewL()
{
CPtr<CFoo> self( new (ELeave)CFoo); //放心, CPtr内部已经PushL了, 保护了这个self
self->ConstructL(); //Leave也无问题, 会调用delete self的.
return self.release(); //release 释放所有权, 这样CPtr析构的时候不会再去delete self.
}
基本上, 你了解STL中的auto_ptr, 也就了解了CPtr. RPtr有点不同, 主要用于使用R class, 它内部放的不是T*,而是直接T本身.
再举个CPtr的例子:
void foo()
{
CPtr<HBufC> wbuf(HBufC::NewL(20)); //分配内存
*wbuf = _L("Hello,world"); //给 HBufC 赋值
wbuf = 0; //释放, 注意HBufC已经释放了, 或者 reset(0)也可以
wbuf = HBufC::NewL(20); //又分配内存
wbuf = HBufC::NewL(40); //哎呀, 不够, 释放刚刚分配的, 分配一块大的内存
*wbuf = _L("long long long hello, world ");
}
基本上和stl中的auto_ptr使用没有什么分别. 不过由于symbian的cleanup机制, 不能将CPtr/RPtr作为成员变量.
下面是源代码: (使用的时候别忘了CPtr, RPtr都是在sbl namespace中, 另外, debug版本中用到了c library的assert)
#include <e32base.h>
#include <libc/assert.h>
#include <libc\string.h>
namespace sbl //sbl stands for SymBian Library
{
// a auto_ptr for any object can be free by "delete" operator
// if you know std::auto_ptr then no much thing you need to study
template<class T>
class CPtr
{
public:
//take a raw pointer, this pointer must not been pushed into cleanup stack
explicit CPtr(T* ptr = 0) : ptr_(ptr)
{
//no matter how we need a slot in cleanup stack
CleanupPushL();
}
//copy ctor, take ownership, just like std::auto_ptr
CPtr(CPtr<T>& other)
{
ptr_ = other.release();
CleanupPushL();
}
//assignment, take ownership, just like std::auto_ptr
CPtr<T>& operator=(CPtr<T>& other)
{
if(this != &other) {
assert( ptr_ != other.ptr_);
reset(other.release());
}
return *this;
}
CPtr<T>& operator=(T* ptr)
{
reset(ptr);
return *this;
}
/* sorry, due to buggy vc6
template<class U>
CPtr(CPtr<U>& other)
{
CleanupPushL();
ptr_ = other.release();
}
template<class U>
CPtr<T>& operator=(CPtr<U>& other)
{
reset(other.release());
reutrn *this;
}
*/
T& operator*() const
{
assert(ptr_ != 0);
return *ptr_;
}
T* operator->() const
{
assert(ptr_ != 0);
return ptr_;
}
// get the raw pointer explicitly
T* get() const
{
return ptr_;
}
void reset(T* ptr = 0)
{
if(ptr != ptr_)
{
delete ptr_; // here we use "delete" to free resource
ptr_ = ptr;
}
}
// release ownership
T* release()
{
T* tmp = ptr_;
ptr_ = 0;
return tmp;
}
//normally exit, dispose
~CPtr()
{
CleanupStack::PopAndDestroy(1, this); // remove from cleanup stack
}
typedef void (*safe_bool)(void *p);
// used by if (c)
operator safe_bool() const
{
return ptr_ ? &Dispose : 0;
}
//used by if(!c)
bool operator!() const
{
return safe_bool(*this) == 0;
}
private:
T* ptr_;
void CleanupPushL()
{
CleanupStack::PushL(TCleanupItem(OnLeave, this));
}
static void OnLeave(void * p);
};
//this function isn't inline since cleanup stack want our function pointer
template<class T>
void CPtr<T>::OnLeave(void * p)
{
CPtr * cptr = static_cast<CPtr*>(p);
cptr->reset(0);
}
//default R class uses Close() to release resource
template<class R>
class RTrait
{
public:
static void Dispose(R& r)
{
r.Close();
}
static bool Connected(const R& r);
};
// default R class check binary bits to determine if connected
template<class R>
bool RTrait<R>::Connected(const R& r)
{
const char * start = (const char *)&r;
const char * end = start + sizeof(R);
for(; start != end; start++)
{
if ( *start != 0)
return true;
}
return false;
}
template<class R, class Trait = RTrait<R> >
class RPtr
{
public:
RPtr()
{
assert(!Trait::Connected(res_));
CleanupStack::PushL(TCleanupItem( OnLeave, this));
}
template<class A1>
RPtr(const A1& a) : res_(a)
{
CleanupStack::PushL(TCleanupItem( OnLeave, this));
}
/*
template<class A1, class A2>
RPtr(const A1& a1, const A2& a2) : res_(a1, a2)
{
CleanupStack::PushL(TCleanupItem( DisposeInvoker, this));
}
template<class A1, class A2, class A3>
RPtr(const A1& a1, const A2& a2, const A3& a3) : res_(a1, a2, a3)
{
CleanupStack::PushL(TCleanupItem( DisposeInvoker, this));
}
*/
~RPtr()
{
CleanupStack::PopAndDestroy(1, this); // remove from cleanup stack and delete
}
R* operator->()
{
return &res_;
}
R& operator*()
{
return res_;
}
R& get()
{
return res_;
}
operator R& ()
{
assert( safe_bool(*this));
return res_;
}
typedef void (*safe_bool)(void*);
// used by if(r)
operator safe_bool() const
{
return Trait::Connected(res_) ? &OnLeave : 0;
}
//used by if(!r)
bool operator!() const
{
return safe_bool(*this) == 0;
}
private:
R res_;
static void OnLeave(void * p);
//noncopyable and assignable
RPtr& operator=(const RPtr&);
RPtr(const RPtr&);
};
template<class R, class Trait>
void RPtr<R, Trait>::OnLeave(void * p)
{
RPtr<R, Trait>* self = static_cast< RPtr<R, Trait>*>(p);
// if(*self) to check if the R class is connected
if(*self) {
Trait::Dispose(self->res_);
assert(!Trait::Connected(self->res_));
}
}
} //end of namespace
#endif
