Accès à la sous-classe des membres d'une super-classe pointeur C++

J'ai un tableau de classe personnalisée Étudiant des objets. CourseStudent et ResearchStudent les deux hérite de l'Étudiant, et de toutes les instances de l'Élève et l'un ou l'autre de ces points.

J'ai une fonction pour aller à travers le tableau, déterminer le sous-type de chaque Élève, puis d'appeler le sous-type spécifique de fonctions membres.

Le problème, car ces fonctions ne sont pas surchargés, ils ne sont pas les Étudiants, de sorte que le compilateur coups de pied jusqu'à une histoire.

Si j'ai un pointeur à l'Étudiant, est-il un moyen d'obtenir un pointeur vers le sous-type de l'Étudiant? Aurais-je besoin de faire une sorte de faux exprimées ici pour l'obtenir autour de la erreur de compilation?

OriginalL'auteur David Mason | 2010-04-01

c++dynamic-cast inheritance static-cast virtual-functions

6

Vous avez besoin d'une dynamique de fonte:
```
Student * s = new ...;    //create student of some sort

if ( ResearchStudent * r = dynamic_cast<ReasearchStudent*>( s ) ) {
   r->ResFunc();
}
else if ( CourseStudent * c = dynamic_cast<CourseStudent*>( s ) ) {
   c->CourseFiunc();
}
else {
   throw "unknown student type";
}
```
Noter que cette utilise les informations de type maintenu par le compilateur, à condition que la classe a au moins une fonction virtuelle - si tout le reste échoue, vérifiez le destructeur virtuel (comme il doit l'être dans ce cas anway). Vous devez toujours préférer cette approche de l'entretien de votre propre type d'informations.

OriginalL'auteur
10

La meilleure chose serait d'utiliser des fonctions virtuelles:
```
class Student
{
   //...
   virtual void SpecificFunction() = 0; /* = 0 means it's abstract; it must be implemented by a subclass */
   //...
};

class CourseStudent
{
    void SpecificFunction() { ... }
};
```
Alors vous pouvez faire:
```
Student *student;
student->SpecificFunction();
```
Un (pire) alternative peut être l'aide de dynamic_cast:
```
Student *student;
CourseStudent *cs = dynamic_cast<CourseStudent *>(student);

if (cs) {
   /* student is a CourseStudent.. */
   cs->SpecificFunction();
}
```
Toutes choses étant égales par ailleurs, la Java/C# point de vue dirais que la dynamique de fonte est mieux, parce que de cette façon, votre pointeur est tapé la façon dont vous souhaitez l'utiliser, au lieu d'être un Student pour lequel un appel à SpecificFunction() donne la CourseStudent valeur de retour. Mais je suis sûr que toutes les choses ne sont pas égaux - de sorte que ce qui est mauvais sur l'utilisation de la dynamique de fonte?

OriginalL'auteur Thomas Bonini
3

Fonctions virtuelles sont inappropriées ici parce que la sous-classe des fonctions membres sont spécifiques aux sous-classes (par exemple la CourseStudent a une liste d'unités, alors qu'un ResearchStudent ne pas, donc un getUnits() fonction de mise en œuvre dans ResearchStudent aurait aucun sens)

J'ai eu un peu de lire sur les dynamiques et statiques jette ( cplusplus.com typecasting ), et dans ce cas je pense qu'un statique de la fonte est plus approprié.

Le grand inconvénient d'un static_cast est qu'il n'effectue pas de vérification au moment de l'exécution pour s'assurer que l'objet de vote à un sous-type est en fait que le sous-type et pas une autre. Dans ce cas, je suis plus précisément de vérifier le type avant de l'-je effectuer le type (à l'aide d'une donnée membre privée, qui est défini dans le constructeur de sous-classe et n'a pas de mutateur), donc tant que mon le contrôle est bon, il devrait y avoir aucun problème avec un statique de la fonte. Une statique de la fonte est plus efficace puisque d'une dynamique de fonte nécessite plus de temps d'exécution des ressources pour effectuer la vérification de type.

Où il y a toute chance d'un membre qui n'est pas le type attendu, statique casting ne serait pas approprié donc je pencherais pour la dynamique de la coulée (cette cession est donc, une fois qu'elle a été présentée le code ne sera pas besoin d'être maintenu, donc il n'y a aucun risque de quelqu'un tout gâcher plus tard).

Je sais que c'était il y a longtemps, mais je voulais dire merci; j'étais juste en face d'un problème très similaire aujourd'hui, et votre réponse m'a fourni exactement la solution que j'ai besoin!
Heureux d'entendre qu'il est toujours utile - rend-il la peine de l'effort de recherche de l'idée de solution.

OriginalL'auteur David Mason
2

Ce n'est presque certainement un cas d'utilisation d'une fonction membre virtuelle pure dans la classe de base, puis en substituant dans les classes dérivées, où vous faire le travail réel.

OriginalL'auteur Marcelo Cantos
1

Vous avez besoin static_cast. Puisque ces fonctions ne sont pas virtuels membres de la classe de base, vous ne pouvez pas les appeler par l'intermédiaire d'un pointeur vers la classe de base pointeur. Vous avez besoin de convertir explicitement le type réel de l'objet.

Ce problème est généralement mieux résolus avec des fonctions virtuelles - vous n'aurez pas besoin de l'objet type de vérification dans votre code, de plus, aura moins de code et de surface pour les bugs.

OriginalL'auteur sharptooth

Vous devez vous connecter pour publier un commentaire.