When using dbstl, make sure memory allocated in the heap is released after use. The rules for this are:
dbstl will free/delete any memory allocated by dbstl itself.
You are responsible for freeing/deleting any memory allocated by your code outside of dbstl.
        When you open a DbEnv or Db object using
        dbstl::open_env() or dbstl::open_db(), you
        do not need to delete that object. However, if you new'd that object and then opened it
        without using the dbstl::open_env() or
        dbstl::open_db() methods, you are responsible for deleting the
        object.
    
        Note that you must new the Db or
        DbEnv object, which allocates it on the heap. You can not allocate it
        on the stack. If you do, the order of destruction is uncontrollable, which makes dbstl
        unable to work properly.
    
        You can call dbstl_exit() before the process exits, to release any
        memory allocated by dbstl that has to live during the entire process lifetime. Releasing the
        memory explicitly will not make much difference, because the process is about to exit and so
        all memory allocated on the heap is going to be returned to the operating system anyway. The
        only real difference is that your memory leak checker will not report false memory leaks.
    
        dbstl_exit() releases any memory allocated by dbstl on the heap.  It
        also performs other required shutdown operations, such as closing any databases and
        environments registered to dbstl and shared across the process.
    
        If you are calling the dbstl_exit() function, and your
        DbEnv or Db objects are new'd by your code,
        the dbstl_exit() function should be called before deleting the
        DbEnv or Db objects, because they need to be
        closed before being deleted.  Alternatively, you can call the
        dbstl::close_env() or dbstl::close_db()
        functions before deleting the DbEnv or Db
        objects in order to explicitly close the databases or environments. If you do this, 
        can then delete these objects, and then call dbstl_exit().
    
    In addition, before exiting a thread that uses dbstl API, you can call the dbstl_thread_exit() function to release any Berkeley DB handles if they are not used by other threads. 
    If you do not call the dbstl_thread_exit() function or call this function only in some threads, all open Berkeley DB handles will be closed by the dbstl_exit()function. 
    You must call the dbstl_exit() function before the process exits, to avoid memory leak and database update loss, if you do not have transactions and persistent log files.
  
        Only when you are storing raw bytes (such as a bitmap) do you have to
        store and retrieve data by using the DbstlDbt helper class. Although you
        also can do so simply by using the Berkeley DB Dbt class, the 
        DbstlDbt class offers more convenient memory management behavior.
    
        When you are storing DbstlDbt objects (such as
        db_vector<DbstlDbt>), you must allocate
        heap memory explicitly using the malloc() function for the
        DbstlDbt object to reference, but you do not need to free the memory
        – it is automatically freed by the DbstlDbt object that owns it
        by calling the standard C library free() function.
    
        However, because dbstl supports storing any type of object or primitive data, it is rare
        that you would have to store data using DbstlDbt objects while using
        dbstl.  Examples of storing DbstlDbt objects can be found in the
        StlAdvancedFeaturesExample::arbitrary_object_storage() and
        StlAdvancedFeaturesExample::char_star_string_storage() methods.