ich habe eine Klassenstruktur

Vater -> Kind1
Vater -> Kind2

die Kinder haben eine GetFunktion die ein Objekt einer Klasse zurückgeben

RetKlasse1 Kind1::getValue();
RetKlasse2 Kind2::getValue();

ich hätte dies gern verallgemeinert,
und würde gern in der BasisKlasse eine Funktion deklarieren, die dies beschreibt.

Zusätzlich würde ich gern ein Objekt zurückgeben und nicht einen Zeiger.

Also eine Lösung wie

void * Vater::getValue()

wäre mir nicht so lieb,
es sei denn ihr überzeugt mich vom Gegenteil.
Ich würde mir gern irgendwelche Speicherlöcher ersparen, daher normale Objekterzeugung.

Danke für Tips ?

class RetBase
{
public:
   //.. Operationen auf abgeleitete Klassen
  ~RetBase (){}
};

class RetKlasse1 : public RetBase
{
 //..
};

class RetKlasse2 : public RetBase
{
 //..
};

class Kind
{
 public:
  RetBase* getValue();
};

Dann hast du eine saubere Schnittstelle für die Ret-Klassen, die du dann um die Funktionalitäten halt noch erweitern musst.ζ

Könnte man elegant irgendwie eine erzeugen ?

Mit der Basisklasse kämst du auch um void Zeiger herum, aber du müsstest halt immernoch die Basisklassen Zeiger casten + noch irgendwie herausfinden können, welches Objekt denn jetzt überhaupt referenziert. (Was ja eigl. gegen den Sinn von Polymorphie ist, aber imo besser als void*).

template <typename Class>
typename return_type<Class>::type getValue(const Class& obj)
{
    return obj.getValue();
}

Die Traitsklasse könnte so aussehen (besseren Namen als return_type wählen):

// Allgemeiner Fall, entweder nichts oder einen Default-Typ definieren
template <typename T>
struct return_type
{
    typedef T type; // Default-Typ
};

// Templatespezialisierung für konkreten Rückgabetypen
template <>
struct return_type<Kind1>
{
    typedef Ret1 type; // konkreter Rückgabetyp für Kind1
};

Um dir genauer helfen zu können, solltest genau sagen, was du brauchst. Am besten illustrierst du es zusätzlich an einem kleinen Stück Code.