c++ - Resource leak during object creation -

i have following code creation of node inside graph. i'm getting resource leak error when run static checking tool (coverity). appreciate if can point out how improve code:

class node {       public :        explicit node(std::string& name) : m_name(name) { }        void setlevel(int level)        { m_level = level; }      private :          ...    }   class graph {      public :         void populategraph()         {            std::string nodename = getnodename();             /* error saying variable new not freed or pointed-to in function               nc::node::node(const std::string...) */            node* nodeptr = new node(nodename);            /* error saying variable nodeptr not freed or pointed-to in function               nc::node::setlevel(int) */             nodeptr->setlevel(-1);            if (m_name2nodemap.find(nodename) == m_name2nodemap.end())                m_name2nodemap[nodename] = nodeptr;            nodeptr = null;         }   ....   private :     std::map< std::string, node*> m_name2nodemap;    } 

thought needed delete nodeptr in populategraph, released call node desctructor (~node) , delete node graph. so, set nodeptr=null see if helps, not.

i not familiar coverity or exact rules uses, seems have memory leak if name of node in map. is, if body of if statement not executed, loose pointer memory allocated. perhaps wanted like:

if (m_name2nodemap.find(nodename) == m_name2nodemap.end())       m_name2nodemap[nodename] = nodeptr;   else     delete nodeptr; nodeptr = null;  

edit: since responded @ same time daemin, let me add more details:

as ildjarn mentioned, need deallocate objects end in map adding destructor:

~graph() {     for( std::map< std::string, node*>::iterator = m_name2nodemap.begin();           != m_name2nodemap.end(); ++i )     {         delete i->second;     } } 

for completeness, should note that:

1. the map deleted automatically after destructor finishes because it's member variable.
2. the entries in node map deleted automatically when map deleted.
3. the string keys deleted when entries deleted.

---

the preferred way deal complex object lifetimes use smart pointer. example, boost::shared_ptr or tr1::shared_ptr work this. note: may not have syntax exact.

class node {        ... }  class graph {       public :       void populategraph()       {           std::string nodename = getnodename();            boost::shared_ptr< node > nodeptr( new node(nodename) );         nodeptr->setlevel(-1);           if (m_name2nodemap.find(nodename) == m_name2nodemap.end())               m_name2nodemap[nodename] = nodeptr;     }       ....       private :           std::map< std::string, boost::shared_ptr<node> > m_name2nodemap;        } }; 

see how we've eliminated destructor , explicit calls delete? node objects destroyed automatically node names.

on node, should std::map::insert function should eliminate if statement together.