ich hab da eine Frage, ist es irgendwie möglich, innerhalb einer Template-Methode zu prüfen ob die Template-Variable ein Zeiger auf ein Objekt ist?

template<class T>
bool CMyFirstTemplate<T>::Insert(T Value)
{

  //...verarbeite Value und wenn Value ein Zeiger auf ein Objekt ist,
  //möchte ich den Speicher freigeben

  if(Value != NULL)
      delete Value;
}

bei dem oben gezeigten Code-Ausschnitt, meckert der Compiler über Zeile 8

ich hoffe, ihr könnt mir da weiterhelfen.

Danke im Voraus!

template< typename type > struct is_pointer_t
{
  enum{ value = 0 };
};

template< template type > struct is_pointer_t< type* >
{
  enum{ value = 1 };
};

template< typename type > is_pointer_t< type > is_pointer( type t )
{
  return is_pointer_t< type >();
}

//Benutzung is_pointer_t< char* >::value
//oder is_pointer( argv ).value

ich würd's gerne herausfinden OHNE die BOOST-Lib zu benutzen

#include <tr1/type_traits>

std::tr1::is_pointer<char*>::value

...
 delete Value;
...

meckern. Oder sehe ich da etwas falsch?

template <typename T> inline void cleanup( T& t )  { }
template <typename T> inline void cleanup( T*& t ) { delete t; } // delete (T*)0; ist harmlos

template<class T>
bool CMyFirstTemplate<T>::Insert(T Value)
{

  //...verarbeite Value und wenn Value ein Zeiger auf ein Objekt ist,
  //möchte ich den Speicher freigeben

  //if(Value != NULL)
  //    delete Value;
  cleanup(Value);
}

danke für den Vorschlag, ich hab's eingebaut und eigentlich hätte es funktionieren müssen, aber zur Laufzeit springt das Programm immer in die erste Variante also:

template <typename T> inline void cleanup( T& t )  { }

und NICHT in:

template <typename T> inline void cleanup( T*& t ) { delete t; }

ich habe die Funktionen nicht als "inline" eingebaut aber das spielt wohl nix zur Sache..

template <class T> struct cleaner
{
    static void clean(T const&){}
}

template <class T> struct cleaner<T*>
{
    static void clean(T* p){ delete p; }
}

template <class T> void clean(T const& t)
{
    cleaner<T>::clean(t);
}

template <typename T>
class default_cleanup_policy
{
public:
  void cleanup( T const& t ) { }

protected:
  ~default_cleanup_policy() { }
};

template <typename T>
class default_cleanup_policy<T*>
{
public:
  void cleanup( T const* t ) { if (auto_delete_) delete t; }

  bool auto_delete() const             { return auto_delete_; }
  void auto_delete( bool auto_delete ) { auto_delete_ = auto_delete; }

protected:
   default_cleanup_policy() : auto_delete_(true) { }
  ~default_cleanup_policy() { }

private:
  bool  auto_delete_;
};

template <
  typename T,
  class cleanup_policy = default_cleanup_policy<T>
>
struct my_first_template : public cleanup_policy
{
  bool tnsert( T const& value )
  {
    //...verarbeite Value und wenn Value ein Zeiger auf ein Objekt ist,
    //möchte ich den Speicher freigeben

    cleanup(value);
  }
}

@finix:
jetzt hab ich aber noch ein paar fragen,
warum funktioniert das Ganze, wenn man's mit Hilfe der zwei cleanup_policy - Klassen macht, nicht aber wenn man einfach zwei Methoden
a la

void cleanup(T const& t) {}
void cleanup(T const* t) { if(auto_delete) delete t; }

in die Klasse implementiert ?!

die zweite Frage bezieht sich auf Zeile 12 in deinem Quelltext.
Kannst du mir kurz erläutern, was das <T>* nach dem Klassennamen bewirkt bzw. was es für die Klasse bedeutet?

ich hab mir die zweite Frage mit dem <T>[\b] gerade selbst beantwortet
das die Klasse mit dem <T> am Ende des Klassennamens ist eine explizite Spezialisierung der Klasse [b]default_cleanup_policy** für einen Zeigertyp von T.
richtig?

ich hab mir die zweite Frage mit dem <T>* gerade selbst beantwortet
das die Klasse mit dem <T*> am Ende des Klassennamens ist eine explizite Spezialisierung der Klasse default_cleanup_policy für einen Zeigertyp von T.
richtig?