Quelles sont les utilisations pratiques d'un constructeur protégé ?

Question

Pourquoi déclarer un constructeur protégé ? Je sais que les constructeurs sont déclarés privés dans le but de ne pas permettre leur création sur la pile.

Answer 1

Pour les méthodes d'usine avec des effets secondaires.

class mine {

  private:
    mine () {};

  protected:
    mine(int id) : m_id(id) {};

   int m_id;
   static int m_count;

  public:
    static mine* CreateOneOfMe() {
         return mine(m_count++);
    }

    int GetId() { return m_id; }

 };

Cela crée des instances de la classe et garantit que chacune d'entre elles possède un identifiant unique incrémentiel. Notez que si le constructeur que vous voulez utiliser n'est pas celui par défaut, vous devez également cacher ce dernier.

Answer 2

Pour permettre à une sous-classe d'utiliser un constructeur qui ne doit pas être accessible directement à un instanciateur.

Answer 3

Vous pourriez l'utiliser pour limiter les classes qui pourraient le créer, par exemple :

class Level
{
private:

 Level();
 ~Level();

 friend class LevelManager;
};

La seule classe qui peut en créer une instance est la classe LevelManager. Vous saurez donc toujours que l'instance Level est créée dans le LevelManager.

Answer 4

Une utilisation du constructeur protégé est de mettre en œuvre le modèle CRTP, voir le code ci-dessous :

#include <iostream>
#include <assert.h>

template <class T>
class ComparableMixin {
public:
    bool operator !=(ComparableMixin &other) {
        return ~(*static_cast<T*>(this) == static_cast<T&>(other));
    }
    bool operator <(ComparableMixin &other) {
        return ((*(this) != other) && (*static_cast<T*>(this) <= static_cast<T&>(other)));
    }
    bool operator >(ComparableMixin &other) {
        return ~(*static_cast<T*>(this) <= static_cast<T&>(other));
    }
    bool operator >=(ComparableMixin &other) {
        return ((*static_cast<T*>(this) == static_cast<T&>(other)) || (*(this) > other));
    }
protected:
    ComparableMixin() {}
};

class Integer: public ComparableMixin<Integer> {
public:
 Integer(int i) {
     this->i = i;
 }
 int i;
 bool operator <=(Integer &other) {
     return (this->i <= other.i);
 }
 bool operator ==(Integer &other) {
     return (this->i == other.i);
 }
};
int main() {

    Integer i(0) ;
    Integer j(1) ;
    //ComparableMixin<Integer> c; //compilation error!
    assert (i < j );
    assert (i != j);
    assert (j >  i);
    assert (j >= i);

    return 0;
}