Enforce a protected constructor in deriving class

Question

Is there any mechanism that allows to enforce a protected constructor in a deriving class?

Simple example:

template<typename T>
class Factory;

class Base {
  template<typename T>
  friend class Factory;
protected:
  Base();
};


class Child : public Base {
public:
  Child(); // this should lead to a compile time error
};

<template T>
class Factory {
Base* GetNew()
{
  BOOST_STATIC_ASSERT(boost::is_base_of<Base, T>::value);

  Base* b = new T();
  b->doStuff();

  return b;
 }
};

So I want the Child class to be only creatable by the factory and enforce that all child classes deriving from Base have a protected constructor.

Answer 1

No, there's no way to enforce this. In general, base classes are very limited in how they can constrain subclasses. Base is not, and should not try to be, responsible for policing everyone who might ever write a class that happened to inherit from Base.

Answer 2

Short answer, no kind of.

protected is the least useful access specifier since any derived class is free to make the name (including the name of a constructor) public.

What you can do is use an access key in the constructor to ensure that only a factory creates the class.

struct factory;

// create_key's constructor is private, but the factory is a friend.
class create_key
{
  create_key() {};
  friend factory;
};

struct only_from_factory
{
  // base constructor demands a key is sent. Only a factory may create a key.
  only_from_factory(const create_key&) {};
};