Pouvez-vous l'emportent sur les fonctions définies dans une classe de base?

Je crois, un derived class peut override ces seules fonctions dont elle a hérité de la base class. Est ma compréhension correcte.?

Qui est le cas de la classe de base a une fonction membre public dire, func, puis la classe dérivée peut override la fonction de membre de func.

Mais si la classe de base a une fonction membre privée dire, foo, puis la classe dérivée ne peut pas annuler la fonction de membre de foo.

Suis-je droit?

Modifier

Je suis venu avec un exemple de code après avoir étudié les réponses données par les membres. Je suis en mentionnant les points que j'ai étudié en tant que commentaires dans le code. De l'espoir, je suis de droite. Grâce

/* Points to ponder:
   1. Irrespective of the access specifier, the member functions can be override in base class.
      But we cannot directly access the overriden function. It has to be invoked using a public
      member function of base class.
   2. A base class pointer holding the derived class obj's address can access only those members which
      the derived class inherited from the base class. */

#include <iostream>

using namespace std;


class base
{
   private:
      virtual void do_op()
      {
         cout << "This is do_op() in base which is pvt\n";
      }

   public:
      void op()
      {
         do_op();
      }
};

class derived: public base
{
   public:
      void do_op()
      {
         cout << "This is do_op() in derived class\n";
      }
};

int main()
{
   base *bptr;
   derived d;

   bptr = &d;
   bptr->op(); /* Invoking the overriden do_op() of derived class through the public 
               function op() of base class */ 
   //bptr->do_op(); /* Error. bptr trying to access a member function which derived class 
                    did not inherit from base class */            

   return 0;
}

OriginalL'auteur nitin_cherian | 2011-11-12

  1. 10

    Vous pouvez remplacer les fonctions indépendamment des spécificateurs d'accès. C'est aussi le cœur de la non-interface virtuelle idiome. La seule exigence est qu'ils sont virtual.

    OriginalL'auteur Xeo

  2. 10

    Mais si la classe de base a une fonction membre privée dire, foo, puis la classe dérivée ne peut pas annuler la fonction de membre de foo.

    En Java, vous ne pouvez pas. En C++, vous pouvez.

    Est-ce caché Java bashing? 🙂 parce que je n'ai pas vu l'OP rien dire à propos de Java.
    Non, c'est juste que beaucoup de programmeurs Java sont surpris quand vous leur dites que vous pouvez remplacer les méthodes privées en C++.
    Merci pour la citation de ma question et à y répondre.

    OriginalL'auteur fredoverflow

  3. 3

    Vous avez raison de remplacer une fonction dans une classe dérivée, il doit hériter de la classe de base (en plus, la classe de base de la fonction doit être virtuel). Cependant vous vous trompez au sujet de votre hypothèse que les fonctions virtuelles ne sont pas héritées. Pour exemple, le code suivant fonctionne bien (et est en fait un idiome connu pour condition préalable/postcondition de la vérification):

    class Base
{
public:
  void operate_on(some thing);
private:
  virtual void do_operate_on(some thing) = 0;
};

void Base::operate_on(some thing)
{
  //check preconditions
  do_operate_on(thing);
  //check postconditions
}

class Derived: public Base
{
  //this overrides Base::do_operate_on
  void do_operate_on(some thing);
};

void Derived::do_operate_on(some thing)
{
  //do something
}

int main()
{
  some thing;
  Base* p = new Derived;

  //this calls Base::operate_on, which in turn calls the overridden
  //Derived::do_operate_on, not Base::do_operate_on (which doesn't have an
  //implementation anyway)
  p->operate_on(thing);

  delete p;
}

    Une façon de voir que les méthodes privées sont vraiment hérité est de regarder les messages d'erreur générés par le code suivant:

    class Base
{
private:
  void private_method_of_B();
};

class Derived:
  public Base
{
};

int main()
{
  Derived d;
  d.private_method_of_B();
  d.method_that_does_not_exist();
}

    Essayer de le compiler avec g++ conduit tot il des messages d'erreur suivants:

    privatemethodinheritance.cc: In function 'int main()':
privatemethodinheritance.cc:4: error: 'void Base::private_method_of_B()' is private
privatemethodinheritance.cc:15: error: within this context
privatemethodinheritance.cc:16: error: 'class Derived' has no member named 'method_that_does_not_exist'

    Si la classe Dérivée ne pas hériter de cette fonction, le message d'erreur serait le même dans les deux cas.

    Dans votre exemple, je peux voir que la fonction do_operate_on qui est un membre privé dans la classe de base est redéfinies dans la classe dérivée. Donc, puisque les membres privés ne sont pas héritées, l'exemple ci-dessus montre que les fonctions peuvent toujours être surchargée bien qu'ils ne sont pas héritées. Votre réponse me confond un peu parce que Björn Pollex et FredOverflow pense différemment de vous. Ils disent que le privé virtuel fonctions peuvent être surchargée
    +1 pour l'exemple de code qui a ouvert l'esprit à l'utilisation de privé virtuel de la fonction membre.
    J'ai maintenant ajouté un exemple de code montrant que la fonction privée est en effet hérité.
    Veuillez préciser. Mettre une ligne de fond de ce "parce que FredOverflow dit"

    OriginalL'auteur celtschk

  4. 0

    Non, Vous ne pouvez plus rouler toute fonction dans la classe de base .
    Ma raison de cette notion est que si vous définissez la fonction dans la classe dérivée qui a la même fonction signiture dans la classe de base , la classe de base de la fonction va être cachées pour la classe dérivée .

    Pour plus d'informations sur cette passionnante question, il suffit de visiter :
    http://publib.boulder.ibm.com/infocenter/comphelp/v8v101/index.jsp?topic=%2Fcom.ibm.xlcpp8a.doc%2Flanguage%2Fref%2Foverload_member_fn_base_derived.htm

    OriginalL'auteur Infintyyy

  5. -2

    Ça dépend aussi du type d'héritage

    class Derived : [public | protected | private] Base { };

    Le type de l'héritage n'a pas d'effet sur la capacité de surcharge de fonctions virtuelles.
    Phalanges, je pense que le type de l'héritage affecte la capacité de remplacer les fonctions. Le code suivant l'habitude de compiler: ideone.com/h59qb
    Cela ne parvient pas à compiler parce que vous tentez de convertir implicitement un pointeur à l'enfant à un pointeur vers la base, qui ne parvient pas, parce que base est privé de la classe de base (c'est pourquoi l'erreur est signalée dans main, au lieu de la définition de child). Cette erreur n'est pas causée par le principal.

    OriginalL'auteur Andrii

  6. -3

    Afin de remplacer une fonction héritée de la classe de base, il devrait être à la fois virtual, et classé comme public ou protected.

    -1: Ce n'est pas correct, vous pouvez remplacer privé des fonctions virtuelles.
    Le code suivant l'habitude de compiler: codepad.org/lFUlNme8
    Mais ce sera: ideone.com/anUoc. Dans votre exemple, vous essayez d'appeler une fonction privée de base. Seulement base peut le faire.
    Merci pour l'extrait de code 🙂 je ne comprends pas quel est l'avantage d'être privé, si le corps de la fonction peut être modifiée dans les classes enfant si facilement
    @Xeo mentionné dans sa réponse, il est utilisé dans le non-virtuel-interface-idiome.

    OriginalL'auteur Meysam