C++ Accès de membre de classe dérivée de la classe de base pointeur

Si j'alloue un objet d'une classe Derived (avec une classe de base de Base), et de stocker un pointeur vers cet objet dans une variable qui pointe vers la classe de base, comment puis-je accéder aux membres de la Derived classe?

Voici un exemple:

class Base
{
    public:
    int base_int;
};

class Derived : public Base
{
    public:
    int derived_int;
};

Base* basepointer = new Derived();
basepointer-> //Access derived_int here, is it possible? If so, then how?

InformationsquelleAutor Peter | 2010-03-12

c++derived-class inheritance pointers

61

Non, vous ne pouvez pas accéder derived_int parce que derived_int fait partie de Derived, tandis que basepointer est un pointeur vers Base.

Vous pouvez le faire dans l'autre sens, si:
```
Derived* derivedpointer = new Derived;
derivedpointer->base_int; //You can access this just fine
```
Issus des classes héritent les membres de la classe de base, et non l'inverse.

Toutefois, si votre basepointer a été pointant vers une instance de Derived alors vous pourriez avoir accès par l'entremise d'un casting:
```
Base* basepointer = new Derived;
static_cast<Derived*>(basepointer)->derived_int; //Can now access, because we have a derived pointer
```
Notez que vous aurez besoin de changer votre héritage à public première:
```
class Derived : public Base
```
- ne devrait-il pas utiliser dynamic_cast au lieu de static_cast?
- Cela dépend de si oui ou non il sait que c'est un Derived ou pas. Si vous êtes sûr à 100% (nous sommes ici) puis static_cast est très bien.
- n'est pas tout le monde veux dire reinterpret_cast au lieu de static_cast? Je suis sûr que static_cast ne compile pas.
- Non, static_cast est la bonne chose ici. reinterpret_cast de dresser, mais il fait quelque chose de mal dans de nombreux cas. reinterpret_cast ne change pas l'adresse stockée dans le pointeur, c'est juste réinterprète il. Cependant, static_cast a parfois besoin de compenser le pointeur (par exemple, si Derived hérité de plusieurs bases)
- Tout d'abord, vous ne pouvez pas utiliser dynami_cast sauf si vous travaillez avec polymorphes classes. Cette classe(es) n'ont pas toutes les fonctions de membre pour vraiment ajouter virtuel comportement. static_cast est la meilleure chose à faire dans le scénario donné.
InformationsquelleAutor Peter Alexander
10

Vous dansez sur le champ de mines ici. La classe de base ne peut jamais savoir que c'est en fait une instance de la dérivée. La meilleure façon de le faire serait d'introduire une fonction virtuelle dans la base:
```
class Base 
{ 
protected:
 virtual int &GetInt()
 {
  //Die horribly
 }

public: 
 int base_int; 
}; 

class Derived : Base 
{ 
  int &GetInt()
  {
    return derived_int;
  }
public: 
int derived_int 
}; 

basepointer->GetInt() = 0;
```
Si basepointer points comme autre chose qu'un Derived, votre programme va mourir horriblement, qui est le résultat prévu.

Alternativement, vous pouvez utiliser dynamic_cast<Derived>(basepointer). Mais vous avez besoin d'au moins une fonction virtuelle dans le Base pour cela, et être prêt à rencontrer un zéro.

La static_cast<>, comme certains le suggèrent, est un moyen sûr de se tirer dans le pied. Ne contribuent pas à la grande cache de "l'insécurité de la C de la famille des langues" histoires d'horreur.
- "Alternativement, vous pouvez utiliser dynamic_cast(basepointer). Mais vous avez besoin d'au moins une fonction virtuelle dans la Base pour que, et être prêt à rencontrer un zéro." --> Bon Point de Seva.Aimé 🙂
- À l'aide de static_cast n'est pas un moyen de se tirer dans le pied. Je pense que vous êtes de le confondre avec un C cast explicite notation (T)x. static_cast sur l'autre main est de type sécurisé, mais dynamic_cast va retourner un pointeur null si il ne peut pas convertir tout static_cast émettra une erreur du compilateur.
InformationsquelleAutor Seva Alekseyev
7

vous pouvez utiliser PFI

fondamentalement, vous utilisez la classe dérivée dans le modèle de la classe de base

InformationsquelleAutor kirill_igum
4

Il est possible, en laissant de la classe de base à connaître le type de la classe dérivée. Cela peut être fait en faisant de la classe de base d'un modèle de type dérivé. Ce C++ langage est appelé curieusement récurrents pattern template.

Sachant que la classe dérivée de la classe de base, le pointeur peut être statique-coulé à un pointeur sur un type dérivé.
```
template<typename DerivedT>
class Base
{
public:
    int accessDerivedField()
    {
        auto derived = static_cast<DerivedT*>(this);
        return derived->field;
    }
};


class Derived : public Base<Derived>
{
public:
    int field;
};

int main()
{
    auto obj = new Derived;
    obj->accessDerivedField();
}
```
InformationsquelleAutor Paweł Bylica
0

//si vous savez ce que la classe dérivée que vous allez utiliser

Dérivés* derivedpointer = dynamic_cast < Dérivés * > basepointer;

//ensuite, vous pouvez accéder à la classe dérivée à l'aide de derivedpointer

InformationsquelleAutor Roger Wang

Vous devez vous connecter pour publier un commentaire.