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);