Übergeben von Eltern * zu Kind <T> * mit unbekanntem T, und erhalten T

Question

Ich habe ein Objekt vom Typ Child, die mit unbekannten T initialisiert wurde. Ich muss ein neues Objekt des gleichen Typs T als dieses Objekt erstellen. Mein Objekt vom Typ Child hat eine untemplated Basisklasse Parent. Mein einziger Zugriff auf mein Objekt vom Typ Child erfolgt über einen Zeiger vom Typ Parent. Ist es möglich, diesen Zeiger auf Parent in einen Zeiger auf das Child-Objekt mit korrektem Template umzuwandeln? Oder sonst T vom Zeiger auf Parent erhalten?

Die einzigen Beispiele, die ich finden kann, kennen bereits T beim Gießen.

struct Parent{ 

}; 

template <typename T> 
struct Child{ 
    typedef T ValueType; 

}; 

template <typename T> 
void foo(Parent*) { } 

// implementation 

Parent* object; // provided from somewhere else, points to Child<T> of unknown T 

foo<T>(object); // PROBLEM because T depends on what T the Child in object was templated with 

Answer 1

Meinst du so etwas (minimales Beispiel)?

struct Parent { 
    virtual Parent * clone() = 0; 
}; 

template<class T> 
struct Child: Parent { 
    Child<T> * clone() override { 
     return new Child<T>; 
    } 
}; 

int main() { 
    Child<int> *c = new Child<int>; 
    Child<int> *cclone = c->clone(); 
    Parent *pclone = c->clone(); 
} 

EDIT

das Snippet Unter Berücksichtigung der OP mit einer Bearbeitung hinzugefügt, hier ist ein leicht modifiziertes Beispiel (basierend auf der gleichen Idee):

struct Parent; 

template <typename T> 
void foo(Parent*) { } 

struct Parent{ 
    virtual void invokeFoo() = 0; 
}; 

template <typename T> 
struct Child: Parent { 
    void invokeFoo() override { 
     foo<T>(this); 
    } 
}; 

int main() { 
    Parent* object = new Child<int>; 
    object->invokeFoo(); 
}