More Effective C++ 26. Limiting Object Instantiations

Counted.h

#pragma once
template<class BeingCounted>
class Counted {
public:
    class TooManyObjects { };
    static size_t objectCount();
protected:
    Counted();
    Counted(const Counted& rhs);
    ~Counted() { --numObjects; }
private:
    static size_t numObjects;
    static const size_t maxObjects;
    void init();
};

template<class BeingCounted>
size_t Counted<BeingCounted>::numObjects = 0;

template<class BeingCounted>
Counted<BeingCounted>::Counted() { init(); };

template<class BeingCounted>
Counted<BeingCounted>::Counted(const Counted<BeingCounted>&) { init(); }

template<class BeingCounted>
void Counted<BeingCounted>::init() {
    if (numObjects >= maxObjects) throw TooManyObjects();
    ++numObjects;
}

Printer.h

#pragma once
#include "Counted.h"
#include <string>

using std::string;

class PrintJob {
public:
    PrintJob() { }
    PrintJob(const string& whatToPrint);
};

class Printer :private Counted<Printer> {
public:
    // pseudo-constructors
    static Printer * makePrinter();
    static Printer * makePrinter(const Printer& rhs);
    ~Printer();
    void submitJob(const PrintJob& job);
    void reset();
    void performSelfTest();
    Counted<Printer>::objectCount;
    Counted<Printer>::TooManyObjects;
private:
    Printer();
    Printer(const Printer& rhs);
};
const size_t Counted<Printer>::maxObjects = 1;
Printer::Printer() { }
Printer::Printer(const Printer& rhs) { }

Printer * Printer::makePrinter() { return new Printer; }

Printer * Printer::makePrinter(const Printer& rhs) { return new Printer(rhs); }