Chapitre :[[cpp:syntax:class:deriving|L'héritage & les classes dérivées]]

====== Déclarer des champs et des méthods dans une classe dérivée======

===== Déclarer des champs dans une classe dérivée ======

Les champs qui sont déclarés dans une classe dérivée ne peuvent pas avoir le même nom que les champs dans une des classes de base.

===== Déclarer des méthodes dans une classe dérivée ======

__**Cas 1**: La méthode ''method'' a un nom différent de celui des méthodes existance dans la classe de base.__

C'est par exemple le cas de la méthode ''previous()'' dans la classe ''bidi_enumerate_characters'' :
<code cpp>
  int previous()
  {
      return mReversePosition >= 0 ? 
        (int)mString[mPosition++] : -1;
  }
</code>

Ce sont les règles habituelles de la déclaration des méthodes dans les classes. La nouvelle méthode s'ajoute aux anciennes méthodes.

__**Cas 2**: La méthode ''method'' a le même nom que celui des méthodes existance dans la classe de base.__

C'est par exemple le cas de la méthode ''reset()'' dans la classe ''bidi_enumerate_characters'' :
<code cpp>
  void reset()
  {
      mPosition = 0;
      enumerate_characters()::reset();
  }
</code>

**Règle 1**: Si nous définissons une ou plusieurs méthodes ayant le nom ''method'' et que des méthodes ayant le même nom ont été définies dans la classe de base, les méthodes ayant comme nom ''method'' sont cachées dans la classe de base. 

<code cpp>
class enumerate_characters
{
private:
  int mPosition;
protected:
  int mNumberOfCharacters;
  const char* mString;
public:
  enumerate_characters(const char* aString, int theNumberOfCharacters):
      mString(aString), mNumberOfCharacters(theNumberOfCharacters) {}
  
  int next()
  {
      return mPosition < mNumberOfCharacters ? 
        (int)mString[mPosition++] : -1;
  }
  void reset()
  {
      mPosition = 0;
  }
}

class extended_enumerate_characters: enumerate_characters
{
public:
  extended_enumerate_characters(const char* aString, int theNumberOfCharacters):
      enumerate_characters(aString, theNumberOfCharacters) {}
  
  int next(int lookup)
  {
      mPosition += increment;
      if(mPosition >= mNumberOfCharacters)
      {
          mPosition = mNumberOfCharacters;
          return (int)-1;
      }
      return (int)mString[mPosition++];
  }
}
</code>

Dans ce cas, la méthode ''next(int)'' va être la seule méthode visible dans la classe  ''extended_enumerate_characters''. La méthode ''next()'' de la classe ''enumerate_characters'' mais elle sera masquée et sera donc inaccessible.

**Règle 2**: Il est possible de rendre visible dans la classe dérivée les méthodes qui ont été définies dans la classe de base est qui ne prennent pas les même arguments que celles définies dans la classe dérivée.

Si nous voulons rendre la méthode ''next()'' visible, il faudra ajouter à la classe ''extended_enumerate_characters'' la directive : ''using enumerate_characters::next'' pour indiquer que les méthodes ayant pour nom ''next'' et étant définie dans la classe de base sont aussi visible dans la classe dérivée.
<code cpp>
class extended_enumerate_characters: enumerate_characters
{
public:
  extended_enumerate_characters(const char* aString, int theNumberOfCharacters):
      enumerate_characters(aString, theNumberOfCharacters) {}

  using enumerate_characters::next;
  int next(int lookup)
  {
      mPosition += increment;
      if(mPosition >= mNumberOfCharacters)
      {
          mPosition = mNumberOfCharacters;
          return (int)-1;
      }
      return (int)mString[mPosition++];
  }
}
</code>

Dans la classe ''extended_enumerate_characters'', les deux méthodes ''enumerate_characters::next()'' et 
''extended_enumerate_characters::next(int)'' sont accessibles. 

<code cpp>
    extended_enumerate_characters enumerator("abcdefg");
    std::cout << enumerator.next(2);
    std::cout << enumerator.next();
</code>

Par contre, dans la classe ''bidi_enumerate_characters'', ajouter ''using enumerate_characters::reset'' ne sert à rien parce que la fonction ''reset()'' dans la classe dérivée à la [[cpp::syntax::functions::overload|même signature]] que la fonction ''reset'' dans la classe de base.

==== Notions associées ====

[[cpp:syntax:class:deriving:virtual_methods|Les méthodes virtuelles]]

Section précédente: [[cpp:syntax:class:deriving:creating|Classe dérivée]]\\ 
Section suivante: [[cpp:syntax:class:deriving:constructor|Les constructeurs]]