C ++: l'accès à des méthodes de parents et les variables

Question

De quelle manière devrais-je accéder à cette méthode parent et variable parent?

class Base
{
public:
    std::string mWords;
    Base() { mWords = "blahblahblah" }
};

class Foundation
{
public:
    Write( std::string text )
    {
        std::cout << text;
    }
};

class Child : public Base, public Foundation
{
    DoSomething()
    {
        this->Write( this->mWords );
        // or
        Foundation::Write( Base::mWords );
    }
};

Merci.

Edit:? Et s'il y a ambiguïté

Answer 1

Les deux syntaxes que vous utilisez dans votre code (this->... et les qualifiés) ne sont nécessaires en particulier quand il y a ambiguïté ou un autre nom problème de recherche, comme cachette de nom, la classe de base de modèle, etc.

Quand il n'y a pas d'ambiguïté ou d'autres problèmes que vous ne pas besoin de ces syntaxes. Tout ce que vous avez besoin est un simple nom non qualifié, comme Write dans votre exemple. Juste Write, non this->Write et non Foundation::Write. De même pour mWords.

i.e.. dans votre exemple spécifique d'une plaine Write( mWords ) fonctionnera très bien.

---

Pour illustrer ce qui précède, si votre méthode de DoSomething avait paramètre mWords, comme dans

DoSomething(int mWords) {
  ...

ce paramètre de mWords locale cachions membre de la classe héritée mWords et que vous devez utiliser soit

DoSomething(int mWords) {
  Write(this->mWords);
}

ou

DoSomething(int mWords) {
  Write(Foundation::mWords);
}

pour exprimer votre intention correctement, à savoir briser le cacher.

---

Si votre classe Child avait aussi son propre membre de mWords, comme dans

class Child : public Base, public Foundation
{
  int mWords
  ...

alors ce nom se cacherait la mWords héritée. L'approche this->mWords dans ce cas, ne serait pas vous aider à unhide le nom propre, et vous auriez à utiliser le nom qualifié pour résoudre le problème

DoSomething(int mWords) {
  Write(Foundation::mWords);
}

---

Si vos deux classes de base avaient un membre de mWords, comme dans

class Base {
public:
  std::string mWords;
  ...
};

class Foundation {
public:
  int mWords;
  ...

puis en Child::DoSomething le nom de mWords serait ambigu, et vous auriez à faire

DoSomething(int mWords) {
  Write(Foundation::mWords);
}

pour résoudre l'ambiguïté.

---

Mais, encore une fois, dans votre exemple spécifique, où il n'y a pas d'ambiguïté et sans nom cacher tout cela est tout à fait inutile.

Answer 2

Comme il n'y a pas de conflit de nommage, utilisez simplement Write(mWords). Utilisez l'autre 2 si vous avez des variables locales qui sont en conflit, ou lorsque les noms sont cachés.

Answer 3

Je pense que c'est la plus approche commune:

Write(mWords);

à moins que vous exécutez dans l'ambiguïté.

S'il y a ambiguïté ou shadowing parce que vous voulez quelque chose dans un (particulier) classe de base, mais quelque chose dans une autre classe de base (ou cette classe) cache, puis utilisez la syntaxe Base::name.

Si une variable locale est shadowing un de vos membres, puis utilisez this->, mais en général, vous devriez essayer d'éviter cette situation. (Ex: essayez d'éviter de nommer les habitants de telle sorte qu'ils ombre membres)

Je suppose que d'une façon de le regarder serait d'utiliser la première de ces œuvres et qui fait ce que vous voulez:

1. name
2. this->name
3. Base::name