How to delete the object that is create inside the local function in c++?

I will explain the scenario using example.

   void func()
   {
     开发者_StackOverflow     CLine* pObj = new CLine();
   }
   void func2()
   {
   }

How to delete the CLine object in func2()? Is it possible?

Thanks

It's not possible. As soon as func finishes you've lost all reference to pObj and leaked its memory.

There is probably no need to use a free-store allocated variable at all in this case. Just do:

void func()
{
       CLine obj;
}
void func2()
{
}

obj will be automatically destroyed at the end of the scope.

If the variable absolutely must be free-store allocated, then you can put it in an unique_ptr as follows:

void func()
{
       const std::unique_ptr<CLine> obj(new CLine());
}
void func2()
{
}

if you are using c++03 then just replace unique_ptr with auto_ptr.

Anyway, if you really must use the code exactly as it is in your example then there is a way to still delete the CLine object. You have to use overloaded operator new and operator delete. It would have to be something like:

#include <vector>
#include <new>
#include <algorithm>
struct CLine {
    //... Other members ...

    static std::vector<void*> pointerCache;

    void* operator new(std::size_t size) throw(std::bad_alloc) {
        while (true) {
            void* pointer(malloc(size));
            if (pointer) {
                try {
                    pointerCache.push_back(pointer);
                    return pointer;
                }
                catch (std::bad_alloc&) {
                    free(pointer);
                }
            }
            if (std::new_handler handler = std::set_new_handler(0)) {
                std::set_new_handler(handler);
                (*handler)();
            }
            else {
                throw std::bad_alloc();
            }
        }
    }

    void operator delete(void *p) throw() {
        pointerCache.erase(std::remove(pointerCache.begin(), pointerCache.end(), p),pointerCache.end());
        free(p);
    }

    void* operator new(std::size_t size, std::nothrow_t const&) throw() {
        try {
            return operator new(size);
        } catch (std::bad_alloc&) {
            return 0;
        }
    }
    //Compressed for space constraints.
    void operator delete(void *p, std::nothrow_t const&) throw(){
        operator delete(p);}
    void* operator new[](std::size_t size) throw(std::bad_alloc){
        return operator new(size);}
    void operator delete[](void *p) throw(){operator delete(p);}
    void* operator new[](std::size_t size, std::nothrow_t const& nothrow) throw(){
        return operator new(size, nothrow);}
    void operator delete[](void *p, std::nothrow_t const& nothrow) throw(){
        operator delete(p, nothrow);}
};
std::vector<void*> CLine::pointerCache;

And then your code could look like this:

void func()
{
    CLine* pObj = new CLine();
}
void func2()
{
    //The most recently added pointer in CLine::pointerCache is
    // the one that was added in func()
    delete static_cast<CLine*> (CLine::pointerCache.back());
}

int main()
{
    func();
    func2();
}    

But really, there is so much wrong with this code that you would be better just changing your design. Some of the problems include: the total confusion that you will cause to people reading your code, the lack of thread-safety, and the use of a global pointerCache object.

It IS possible if func() and func2() are methods of the same class, and pObj is a member variable of that class. I realize this is not how you structured your question, but this is one way to get the effect you are looking for

class MyClass
{
    CLine* pObj;

     void func()
     {
          pObj = new CLine();
     }
     void func2()
     {
         delete pObj;
     }
}

Yes you can.

void func()
{
     CLine* pObj = new CLine();
}

void func2(CLine* pObj)
{
     delete pObj;
}

if you pass CLine pointer to func2

No, it's not possible. Because the only copy of the pointer is lost when func goes out of scope, you no longer have a reference to the memory to use with operator delete.

You have to delete the object you created dynamically in a function inside the function itself. If you leave the function without deleting it, you cannot delete it and the memory is lost.