delete doesn't appear to delete

[mop65715]

The singleton class based off the CRTP is not provided, nonetheless consider.

# include <iostream>
# include <map>
# include <string>
# include <vector>

class Base { 
public: 
  virtual ~Base() {} 
};

class  Derived : public Base { 
public: 
  Derived()  {}
  ~Derived() { std::cout << "o" << std::endl; } 
};

enum TEST_KEYS { A, B, C, END_OF_KEYS };

class test :  public singleton < test > {
  typedef TEST_KEYS test_keys;
  Base *key_list[ END_OF_KEYS ];
public :
 template < typename ClassType >
 test& insert ( test_keys const & key, ClassType * ptr ) {
   if ( key_list [ key ] != 0 ) {
     throw ( std::runtime_error( "key exists" ) );
   } 
   key_list [ key ] = ptr;
   return ( *this );
  }

 template < typename ClassType >
 Derived& Get ( test_keys const & key ) {
   if ( key_list [ key ] == 0 ) {
     throw ( std::runtime_error( "no match" ) );
   }
   //I think static_cast here should suffice
   return static_cast< ClassType& >( *( key_list [ key ] ) );
  }

   template < typename ClassType >
   void Delete ( test_keys const & key ) {
     if ( key_list [ key ] != 0 ) {
       delete key_list[ key ];
     }
   }
};

//later 
int main() {

  for ( int odx ( 0 ) ; odx < 2; ++odx ) {
    test::instance().insert < Derived >(  A, new Derived () );
    //now remove it...
    test::instance().Delete < Derived > ( A ) ;
  }
  std::cin.get();
}

It appears that the derived class 'Derived' is not being 'Deleted' from the m_list even though it's clear from debugging and stream output that the destructor of the Derived class is called. That said, on the next call to insert (i.e when odx = 1) the exception 'key exists' is thrown. (I'll admit that after a handful of years with C++ I'm embarassed to admit I'm struggle with what appears to be the basics)

How do I resolve this?

[superbonzo]

after deleting the key you should also reset the pointer to 0; otherwise the "key_list [ key ] != 0" check in the insert function will fail ( BTW, note that the key_list array is zero initialized just because the singleton instance is probably a global variable... )

[Lindley]

I would recommend explicitly 0-initializing the key_list array. Even if it happens automatically, that isn't something you want to take chances with.

Calling delete will definitely *not* automatically NULL-out the pointer passed to it. It simply renders the address held by the pointer invalid, nothing more.

[mop65715]

superbonzo and Lindley(as always) thanks. On a separate note: Consider this line

   //I think static_cast here should suffice
   return static_cast< ClassType& >( *( key_list [ key ] ) );

The _static_cast_ should suffice. Correct?

[Lindley]

I think it's a bit odd that you've made that a template function *and* are making Derived the return type. I'd think you would make the return type the templated ClassType.

Given that you're using a template to cast down a base class, I'd recommend using dynamic_cast. An extra check won't slow you down too much, and could save you grief later.

[mop65715]

I think it's a bit odd that you've made that a template function *and* are making Derived the return type. I'd think you would make the return type the templated ClassType.

Could you elaborate on the part starting with 'I'd think ... .ClassType'. Not sure if I follow you...

[Lindley]

 template < typename ClassType >
 Derived& Get ( test_keys const & key ) {
   if ( key_list [ key ] == 0 ) {
     throw ( std::runtime_error( "no match" ) );
   }
   //I think static_cast here should suffice
   return static_cast< ClassType& >( *( key_list [ key ] ) );
  }

This template will only ever compile when instantiated with Derived, or a class further deriving from Derived.

[D_Drmmr]

The _static_cast_ should suffice. Correct?

Given that you're using a template to cast down a base class, I'd recommend using dynamic_cast. An extra check won't slow you down too much, and could save you grief later.

You could consider using boost::polymorphic_downcast. It asserts the type with a dynamic_cast in debug, but uses a static_cast in release.
The book "C++ coding standard" by Sutter and Alexandrescu describes the same idea in chapter 93 (they call the function checked_cast).