Gegeben folgende Klassenstruktur:

template<typename> class Vater;

class Sohn: public Vater<Sohn>;
class Tochter: public Vater<Tochter>;

Gibt es einen Weg, Objekte vom Typ Tochter und Sohn über einen gemeinsamen Zeiger anzusprechen? Naiv natürlich nicht, da Vater<Sohn> und Vater<Tochter> grundverschieden sein könnten. Aber ich als Programmierer weiß ja, dass die Unterschiede an der Codestelle an der ich das brauche nicht von Belang sind. Ich benutze nur Sachen, die nichtstatische Eigenschaften des Vater-Templates sind. Könnte man da vielleicht mit Mehrfachvererbung was tricksen?

Was ich vor habe:
Abhängig vom ziehen einer Zufallszahl wird etwas mit einem Objekt vom Typ Tochter oder Sohn gemacht. In Pseudocode so:

template<typename> class Vater{
 public:
 int unproblematisch;

[...problematischere Sachen...]

};

class Sohn: public Vater<Sohn>;
class Tochter: public Vater<Tochter>;

int main(){
 Sohn sohn;
 Tochter tochter;

 Vater *vater;   // Geht natürlich nicht

 if (zufallszahl==0) vater=&sohn;
 else vater=&tochter;

 vater->unproblematisch0;

}

Sonst kannst Du noch folgendes machen:

class GrossVater
{
protected:
  int unprob_;
public:
  int unprob() const {return unprob_;}
};

template<typename T>
class Vater : public GrossVater { ... };

...

Sohn s;
GrossVater* p = &s;
p->unprob();

Gruß,
SP

Ich würde an Deiner Stelle nochmal ganz doll darüber nachdenken, was der Template-Parameter da soll und ob "public inheritance" überhaupt "richtig" verwendet wird.

Ja, habe ich schon gemacht, bevor ich so ein ungewöhnliches Konstrukt aufgesetzt habe. Es ist das, was in 99% Prozent der Fälle brauche, nur jetzt brauche ich einmal das hier beschriebene, wo das ganze nicht mehr so gut passt.

Das ich alles public gemacht habe hier im Beispiel war nur Schreibfaulheit.

class GrossVater
{
protected:
  int unprob_;
public:
  int unprob() const {return unprob_;}
};

template<typename T>
class Vater : public GrossVater { ... };

...

Sohn s;
GrossVater* p = &s;
p->unprob();

Hehe, da hat mein Unterbewusstsein mit der Wahl der Familienmetapher wohl gar nicht so falsch gelegen. Danke für die Lösung.

Ich werde sie allerdings nicht verwenden, da es bei mir bereits einen Großvater gibt, der ebenfalls ein Template ist, jedoch hat mich das ganze auf eine ähnliche Idee gebracht, die bei mir passt:

class Großmutter{
public:
 int unproblematisch;
};

template<typename> class Vater: public Großvater<Vater<T> >, public Großmutter{
 };

class Sohn: public Vater<Sohn>;
class Tochter: public Vater<Tochter>;

Und dann einen Zeiger auf Großmutter verwenden. Finde ich irgendwie passend, denn mit dieser Metapher kommen alle Probleme aus der männlichen Seite der Verwandschaft

P.S. Nicht ganz ernst zu nehmen.