113

Why would anyone declare a constructor protected? I know that constructors are declared private for the purpose of not allowing their creation on stack.

DavidRR
  • 18,291
  • 25
  • 109
  • 191
Amol Gawai
  • 3,220
  • 4
  • 23
  • 25

9 Answers9

137

When a class is (intended as) an abstract class, a protected constructor is exactly right. In that situation you don't want objects to be instantiated from the class but only use it to inherit from.

There are other uses cases, like when a certain set of construction parameters should be limited to derived classes.

H H
  • 263,252
  • 30
  • 330
  • 514
  • 9
    +1 But the doesn't necessarily have to be an abstract class. It's often the case though. – rtn Jun 29 '09 at 08:59
  • 4
    Isn't it sufficient to declare a function to be pure virtual for defining a base class? Or the above is in absence of pure virtual function. What is a creation event for a Derived class of such an Abstract class? – Amol Gawai Jun 29 '09 at 12:41
  • @Henk Holterman It certainly does - see Section 10.4 of the C++ Standard, entitled "Abstract Classes" –  Jun 29 '09 at 13:04
  • C++ only has an implicit concept of abstract class, based on the presence of abstract functions. If you have an architecturally abstract class w/o pure virtuals, there is no direct way of marking it abstract. – H H Jun 29 '09 at 13:11
  • The presence of a PVF is "explicit", in any version of the English language I've ever come across. –  Jun 29 '09 at 13:22
  • Neil, but what if I want an abstract class w/o a PVF? C# and Java have "abstract class X", that is what I call explicit. – H H Jun 29 '09 at 13:26
  • So you want an unecessary "abstract" keyword? That's not the way C++ works. But it doesn't mean that there is no concept of an abstract class when the meaning of such a thing is EXPLICITLY described in the C++ standard itself! –  Jun 29 '09 at 13:33
  • 7
    Neil, I am not waging a language war here, just answered what protected ctor is good for. But you should be able to appreciate that there is a design-level concept of abstract class, and that it differs from the C++/Delphi definition. – H H Jun 29 '09 at 13:43
  • 8
    The canonical way to indicate a class is abstract is to make the destructor pure virtual. But I tend to make the constructors protected as well, both for "belt and suspenders" protection, and to make it clear to clients they cannot directly instantiate an object of the class. – JohnMcG Jun 29 '09 at 13:58
  • 2
    Combining with answers and comments, this answer is good for me to accept. – Amol Gawai Jun 30 '09 at 05:45
  • If you want to make a class abstract without forcing anyone to override any specific method, you can make the destructor pure virtual. – curryage Apr 03 '13 at 14:09
15

Non-public constructors are useful when there are construction requirements that cannot be guaranteed solely by the constructor. For instance, if an initialization method needs to be called right after the constructor, or if the object needs to register itself with some container/manager object, this must be done outside the constructor. By limiting access to the constructor and providing only a factory method, you can ensure that any instance a user receives will fulfill all of its guarantees. This is also commonly used to implement a Singleton, which is really just another guarantee the class makes (that there will only be a single instance).

The reason for making the constructor protected, rather than private, is the same as for making any other method or field protected instead of private: so that it can be inherited by children. Perhaps you want a public, non-virtual factory method in the base class, which returns references to instances of the derived classes; the derived classes obviously want access to the parent constructors, but you still don't want to be creating them outside of your factory.

Nick Lewis
  • 4,150
  • 1
  • 21
  • 22
12

A protected constructor can be used to make a class effectively abstract when none of its methods are pure-virtual.

It is not quite abstract in the C++ sense since friend classes can still use it without overriding, but then you would have to declare these.

András Aszódi
  • 8,948
  • 5
  • 48
  • 51
Guidobot
  • 131
  • 1
  • 4
9

A protected constructor means that only derived members can construct instances of the class (and derived instances) using that constructor. This sounds a bit chicken-and-egg, but is sometimes useful when implementing class factories.

  • 4
    Technically, this applies only if ALL ctors are protected. – MSalters Jun 29 '09 at 09:09
  • 2
    friend classes can also call the protected constructor (not just derived classes). – Daniel Goldfarb Sep 29 '13 at 03:48
  • ...and a use of a friend class calling the protected constructor would be in the case of an object that has members that are constant (set by the constructor) but need to be public, but never to be set by any other public access, guarantees that the object wont be created somewhere else and the data therefore would not be modified anywhere else either. – osirisgothra Mar 02 '14 at 17:37
8

one use could be factory patterns

Umair Ahmed
  • 11,238
  • 5
  • 33
  • 39
6

For factory methods with side-effects.

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; }

 };

This creates instances of the class and guarantees that each of them has a unique incrementing integer id. Note that if the constructor you want to use is not the default, you must hide the default too.

sean riley
  • 2,633
  • 1
  • 22
  • 22
4

To let a subclass use a constructor that should not be accessible to an instantiator directly.

Oliver Hanappi
  • 12,046
  • 7
  • 51
  • 68
3

You could use it to limit the classes that could create it, for example:

class Level
{
private:

 Level();
 ~Level();

 friend class LevelManager;
};

The only class that can create an instance of it is the LevelManager class, so you will always know that the Level instance is created in the LevelManager.

Pavel
  • 7,436
  • 2
  • 29
  • 42
1

One use of protected constructor is to implement the CRTP pattern, see the code below:

#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;
}
bigdata2
  • 999
  • 1
  • 11
  • 17