La fonction de constructeur dans une classe virtuelle pure doit être “protégé” ou “public”?

L'exemple suivant est tiré du livre "à l'Intérieur de C++ object model"

class Abstract_base {
public:
    virtual ~Abstract_base () = 0;
    virtual void interface () const = 0;
    virtual const char* mumble () const 
    {
        return _mumble;
    }
protected:
    char *_mumble;
};

L'auteur dit que si je veux initialiser _mumble, le membre de données de la pure classe de base virtuelle, un "protégés constructeur" devraient être mises en œuvre.

Mais pourquoi protégé? Et pourquoi "constructeur public" n'est pas adapté pour cette classe?

Merci pour vos réponses, et il serait parfait si il y a un exemple~~ 🙂

Son pur-virtuel. La seule valide la construction d'une telle chose est par l'intermédiaire de dérivation. Dit dérivée a accès à un protégé constructeur. Rien d'autre (les amis de ne pas résister). Il n'a pas d'importance dans ce cas, mais au moins vous savez que pourquoi.
Il convient, en effet, mais personne, à l'exception de la classe dérivée peut appeler cela de toute façon.

OriginalL'auteur Wizmann | 2014-06-04

  1. 6

    Il n'a pas vraiment d'importance, puisque vous n'êtes pas autorisés à construire des objets de la classe de base de toute façon. Rendant protected sert uniquement comme un rappel du fait que la classe est censé être une classe de base; c'est seulement cosmétique/documentation.

    Envisager

    struct Base {
    virtual ~Base() = 0;
  protected:
    Base() { std::puts("Base constructor"); }
};

Base::~Base() { std::puts("Base destructor"); }

struct Derived : Base {};

int main()
{
    //Base b;   //compiler error
    Derived d;

    Base *b = new Derived();
    delete b;
}

    Retrait de la protected ne change pas le sens du programme en aucune façon.

    Pourquoi avez-vous changé la 'classe' à 'struct'?
    Donc il n'a pas besoin d'écrire "public:" avant le destructeur, je suppose.

    OriginalL'auteur Fred Foo

  2. 5

    Les classes abstraites et la construction de telles

    Il n'a pas d'importance si le constructeur est public ou protégé, depuis un classe abstraite ne peut pas être instanciée.

    Vous devez hériter d'elle afin de l'avoir du constructeur appelé, et depuis le Dérivés classe appelle le constructeur de la classe abstraite il n'importe pas quel niveau de protection que vous choisissez, aussi longtemps que le Dérivés classe peut accéder.

    L'une des raisons que l'on pourrait avoir pour faire de ce protected est de servir comme un rappel que la classe doit être construit par héritage, mais honnêtement, qui doit être assez clair quand il voit qu'il a virtuelle pure états-fonctions.

    exemple extrait

    struct B {
  virtual void func () = 0;
  virtual ~B () = 0 { };
};

B::~B () { }

    struct D : B {
  void func () override;
};

    int main () {
  B b; //will error, no matter if Bs ctor is 'public' or 'protected'
       //due to pure virtual member-function

  D d; //legal, D has overriden `void B::func ()`
}
    Je suis d'accord qu'il doit cependant être clair pour la clarté l'objectif, il peut encore aider (mais alors il devient subjectif, bien sûr).

    OriginalL'auteur Filip Roséen - refp

  3. 3

    Une classe virtuelle pure ne peut pas être instanciée, il ne fait pas de différence si le constructeur est public ou protégé.

    Un constructeur public est syntaxiquement correct. Toutefois, il a protégé portera une meilleure indication que la classe ne peut pas être instanciée.

    Pour un exemple: http://ideone.com/L66Prq

    #include <iostream>
using namespace std;

class PublicAbstract {
public:
    PublicAbstract() { }        
    virtual void doThings() =0;
};

class ProtectedAbstract {
protected:
    ProtectedAbstract() { }     
public:
    virtual void doMoreThings() =0;
};

class B: public PublicAbstract {
public:
    void doThings() { } 
};

class C: public ProtectedAbstract {
public:
    void doMoreThings() { } 
};

int main() {
    B b;
    C c;
    return 0;
}

    OriginalL'auteur jsantander

  4. 2

    Un constructeur public ne serait pas très utile, puisque les classes abstraites ne peuvent pas être instanciées en premier lieu.

    Protégé constructeur de sens: de cette façon, un dérivé de la classe de béton peut fournir ses propres constructeur public qui est lié à l'protégé constructeur de la base de la classe abstraite.

    OriginalL'auteur Frédéric Hamidi

  5. 0

    Protecetd ctor sera assurez-vous que le ctor est appelée uniquement par les classes qui dérivent de Abstract_base.

    Public ctor n'est pas approprié parce que la classe contient une pure virtual méthode! Comment envisagez-vous pour instancier un pur-classe virtuelle si pas par l'intermédiaire de son enfant des classes?

    OriginalL'auteur CinCout