Type* ptr=new Type();

    Type* ptr=0;
    ptr=new Type();

    T_SmartPtr<Type> ptr=new Type();

Type* createType()
{
    Type* ptr=new Type()
    //......
    return ptr;
}

T_SmartRefPtr<Type> createType()
{
    T_SmartRefPtr<Type> ptr=new Type()
    //......
    return ptr;
}

    Type* ptr=0;
    {
        T_SmartPtr<Type> sptr=new Type();
        ptr=sptr;
    }//здесь обьект будет удален и ptr стенет инвалидным

void foo(Type* p)
{
    //.....
}
void bar()
{
    T_SmartPtr<Type> ptr=new Type();
    foo(ptr);
}//здесь обьект будет удален после выхода из foo и проблем не возникнет

//Передача по ссылке ибо T_SmartRefPtr хотя и легок но лишние копирование не нужно
void foo(const T_SmartRefPtr<Type>& p)
{
    //.....
}
void bar()
{
    T_SmartRefPtr<Type> ptr=new Type();
    foo(ptr);
}//теперь если foo сохранит указатель то сдесь удаление обьекта не произойдет

    T_SmartRefPtr<Type> sptr1=new Type();
    Type* ptr=sptr;
    T_SmartRefPtr<Type> sptr2=ptr;

    T_SmartRefPtr<Type> ptr=new Type();
    delete ptr;

void func()
{
  
  {
     ClassA a;
     a.method();
  }

  {
     ClassB b;
     b.method();
  }

}

UgN>void func()
UgN>{
UgN>  
UgN>  {
UgN>     ClassA a;
UgN>     a.method();
UgN>  }

UgN>  {
UgN>     ClassB b;
UgN>     b.method();
UgN>  }

UgN>}

     ClassA().method();
     ClassB().method();

WH>>    T_SmartPtr<Type> ptr=new Type();
WH>>

class CDeleteOnExit
{
    void* m_p;
    bool m_bArray;
public:
    CDeleteOnExit(void* _p, bool _bArray = false ): m_p(_p), m_bArray(_bArray) {};
    ~CDeleteOnExit()
    {
        if(m_bArray) delete[](m_p);
        else delete(m_p);
    }
};
#define DELETE_ON_EXIT(x) CDeleteOnExit _CDeleteOnExit##x(x);
#define DELETE_ARRAY_ON_EXIT(x) CDeleteOnExit _CDeleteOnExit##x(x, true);

template <class T_C>class T_CoAutoArr
{
    T_C* m_Arr;
public:
    T_CoAutoArr(int count)
        :m_Arr(0)
    {
        m_Arr=(T_C*)CoTaskMemAlloc(count*sizeof(T_C));
    }
    ~T_CoAutoArr()
    {
        CoTaskMemFree(m_Arr);
        m_Arr=0;
    }
    operator T_C*()
    {
        return m_Arr;
    }
    T_C* Detach()
    {
        T_C* t=m_Arr;
        m_Arr=0;
        return t;
    }
};

//В отличии от CComPtr можно засунуть в slt'ные контейнеры
template<class T_C>class T_CoPtr
{
    T_C* m_Ptr;
public:
    T_CoPtr()
        :m_Ptr(0)
    {}
    T_CoPtr(const T_CoPtr& o)
        :m_Ptr(o.m_Ptr)
    {
        if(m_Ptr)m_Ptr->AddRef();
    }
    T_CoPtr(T_C* o)
        :m_Ptr(o)
    {
        if(m_Ptr)m_Ptr->AddRef();
    }
    T_CoPtr& operator=(const T_CoPtr& o)
    {
        if(this==&o)return *this;
        if(m_Ptr==o.m_Ptr)return *this;
        if(m_Ptr)m_Ptr->Release();
        m_Ptr=o.m_Ptr;
        if(m_Ptr)m_Ptr->AddRef();
        return *this;
    }
    T_CoPtr& operator=(const T_C* o)
    {
        if(m_Ptr==o)return *this;
        if(m_Ptr)m_Ptr->Release();
        m_Ptr=o;
        if(m_Ptr)m_Ptr->AddRef();
        return *this;
    }
    ~T_CoPtr()
    {
        if(m_Ptr)m_Ptr->Release();
    }
    T_C* ClonePtr()
    {
        if(m_Ptr)m_Ptr->AddRef();
        return m_Ptr;
    }
    T_C* operator ->()
    {
        return m_Ptr;
    }
    operator T_C*()
    {
        return m_Ptr;
    }
};

STDMETHODIMP CSRCOMMOPCGroup::AddItems( 
/* [in] */                        DWORD dwCount,
/* [size_is][in] */                OPCITEMDEF *pItemArray,
/* [size_is][size_is][out] */    OPCITEMRESULT **ppAddResults,
/* [size_is][size_is][out] */    HRESULT **ppErrors
)
{
    LogPrint(L"IOPCItemMgt::AddItems\n");
    if(m_Public)        return OPC_E_PUBLIC;
    if(dwCount<=0)        return E_INVALIDARG;
    if(!pItemArray)        return E_INVALIDARG;
    if(!ppAddResults)    return E_INVALIDARG;
    if(!ppErrors)        return E_INVALIDARG;
    *ppAddResults=0;
    *ppErrors=0;
    T_CoAutoArr<HRESULT>        hr(dwCount);
    T_CoAutoArr<OPCITEMRESULT>    ir(dwCount);
    if(!hr||!ir)return E_OUTOFMEMORY;
    UINT fails=0;
    {//Sync
        C_SyncHelper lockDItem(g_DItemSync, C_SyncHelper::StateWrite);
        C_SyncHelper lockThis(this, C_SyncHelper::StateWrite);
        for(UINT i=0;i<dwCount;i++)
        {
            T_CoPtr<COPCGroupItem> p=new COPCGroupItem(this);
            int h=m_Items.Include(p);
            hr[i]=p->Init(&pItemArray[i], &ir[i], h);
            if(FAILED(hr[i]))
            {
                fails++;
                m_Items.Exclude(h);
                ir[i].dwAccessRights        =0;
                ir[i].dwBlobSize            =0;
                ir[i].hServer                =g_ItemIndex.end();
                ir[i].pBlob                    =0;
                ir[i].vtCanonicalDataType    =VT_ERROR;
                ir[i].wReserved                =0;
            }
        }
    }
    *ppAddResults=ir.Detach();
    *ppErrors=hr.Detach();
    if(fails)    return S_FALSE;
    else        return S_OK;
}

STDMETHODIMP CIOPCItemMgt::AddItems( 
    DWORD            dwNumItems,
    OPCITEMDEF     * pItemArray,
    OPCITEMRESULT ** ppAddResults,
    HRESULT       ** ppErrors
    )
{
    unsigned int    i;
    OPCITEMRESULT *ir;
    HRESULT *hr;
    SYSTEMTIME SystemTime;
    BOOL    ok = TRUE;
    COPCItem    *pItem;

    GetApp()->DisplayEvent ("IOPCItemMgt::AddItems");

    // First - allocate memory for the result array(s)
    //
    ir = (OPCITEMRESULT*)GetApp()->pIMalloc->Alloc(sizeof(OPCITEMRESULT) * dwNumItems);    //acc001
    if(ir == NULL)
        {
        *ppAddResults = NULL;
        *ppErrors = NULL;
        return (E_OUTOFMEMORY);
        }

    *ppAddResults = ir;

    hr = (HRESULT*) GetApp()->pIMalloc->Alloc(sizeof(HRESULT) *dwNumItems);        //acc001
    if (hr == NULL)
        {
        GetApp()->pIMalloc->Free(ir);    
        *ppAddResults = NULL;
        *ppErrors = NULL;
        return (E_OUTOFMEMORY);
        }

    *ppErrors = hr;

    // Now for each item... 
    //
    for(i=0; i<dwNumItems; i++)
        {
        hr[i] = GetApp()->ValidateItem (&pItemArray[i], &ir[i]);

        if (hr[i] == S_OK)
            {//Как это работает одному ... известно.
            // Create a new OPCItem
            pItem = new (COPCItem);//А если ехепшен вылетит?

            pItem->Name = pItemArray[i].szItemID;
            pItem->AccessPath = pItemArray[i].szAccessPath;
            pItem->IsActive = pItemArray[i].bActive;
            pItem->NativeDataType = VT_R4;
            pItem->RequestedDataType = pItemArray[i].vtRequestedDataType;
            pItem->Value = 0.0;
            pItem->Quality = OPC_QUALITY_UNCERTAIN;
            GetSystemTime(&SystemTime);        // Get current UTC Time
            SystemTimeToFileTime(&SystemTime, &(pItem->TimeStamp)); // and store it
//RTFM CoFileTimeNow
            pItem->ClientHandle = pItemArray[i].hClient;
            // Server Handle will be assigned by Group
            pGroup->AddItem(pItem);

            // Set ITEM RESULT
            ir->hServer = pItem->SvrHandle;
            ir->vtCanonicalDataType = pItem->NativeDataType;
            ir->dwAccessRights = OPC_WRITEABLE | OPC_READABLE;
            ir->pBlob = NULL;
            ir->dwBlobSize = 0;
            }

        }

    for (i=0; i<dwNumItems; i++)
        {
        if (hr[i] != S_OK)
            return (E_FAIL);    // Some Items could not be added//это не соответствие стандарту OPC
        }
    
    return (S_OK);

}

class Foo
{
    public:
        Foo() { cout<<"Foo::Foo()"<<endl; };
        ~Foo() { cout<<"Foo::~Foo()"<<endl; };
};

void f1()
{
    cout<<"f1()"<<endl;
    Foo* p = new Foo;
    DELETE_ON_EXIT(p);
}

void f2()
{
    cout<<"f2()"<<endl;
    Foo* p = new Foo;
    delete p;
}


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

    f1();
    f2();
 
    return 0;
}

A>...
A>Для себя я давным-давно сформулировал одно простое правило, успешно корректирующее мой собственный стиль написания программ: программа пишется для того, чтобы она работала.

A>Первое, что из этого вытекает, это то, что код должен быть удобочитаемым...