NewL() 和NewLC()各适用于什么情况

具有二阶构造函数的类有两个创建对象的方法：NewLC()和NewL()
对于NewLC(),当指针为自动变量时，应该使用该函数，创建对象后，可以调用其成员函数，使用完毕后，需要调用CleanupStack::PopAndDestroy()释放对象资源。
对于NewL()，当指针为类成员变量时，应该使用该函数，这是因为此时没有必要将指针对象压入清理栈中，因为即使发生Leave，在类的析构函数中仍会对其进行内存释放。当然，这样保证该类是继承自CBase，只有继承自CBase的类在发生Leave时，仍会调用其析构函数。示例代码如下：

class CA : public CBase
{
public:
       CA(TInt aData = 0)
       {
              iData = aData;
              console->Printf(_L("CA::iData = %d/n"), iData);
       }

       TInt iData;
};

class CB : public CBase
{
public:
        static CB* NewL(TInt aData);
        static CB* NewLC(TInt aData);
        ~CB() { delete iCA; }

        CA* iCA;

protected:
        void ConstructL(TInt aData);
        CB() {}
};

CB* CB::NewL(TInt aData)
{
       //User::Leave(1); //在这里设置Leave来测试是否仍调用CC的析构函数
        CB* self = NewLC(aData);
        CleanupStack::Pop(self);
        return self;
}

CB* CB::NewLC(TInt aData)
{
        CB* self = new(ELeave)CB;
        CleanupStack::PushL(self);
        self->ConstructL(aData);
        return self;
}

void CB::ConstructL(TInt aData)
{
i       CA = new(ELeave)CA(aData);
}

class CC : public CBase
{
public:
        static CC* NewL(TInt aData);
        static CC* NewLC(TInt aData);
        ~CC()
        {
                console->Printf(_L("~CC()/n"));
               delete iCB;
        }

protected:
        void ConstructL(TInt aData);
        CC() { }

       CB* iCB;
};

CC* CC::NewL(TInt aData)
{
         CC* self = NewLC(aData);
         CleanupStack::Pop(self);
         return self;
}

CC* CC::NewLC(TInt aData)
{
        CC* self = new(ELeave)CC;
        CleanupStack::PushL(self);
        self->ConstructL(aData);
        return self;
}
void CC::ConstructL(TInt aData)
{
        console->Printf(_L("CC::ConstructL()/n"));
        iCB = CB::NewL(aData);
}

主函数中代码：
   CC* pCC = CC::NewLC(11);

   // call other functions

   CleanupStack::PopAndDestroy(pCC);