C++ instance counter

Nice use of the "Curiously Recurring Template Pattern".

The trouble with your design, is that any user of your class needs to declare their own version of the s_counter. Not strictly a problem but it does make it harder to use.

I would use static function variable as the counter. That way you don't actually need to declare your own version.

    struct counter
    {
        private:
            // Should not be used by friends.
            static std::atomic<uint32_t>& getCounterInstance() {
                static std::atomic<uint32_t>  counter = 0;
                return counter;
            }
    };

As counter is a private member of countable. Nobody else can see it (let alone access it). So you don't need to make countable a friend. Just use some standard public functions to get you accesses.

template<typename t_derived>
class countable
{
    struct counter
    {
        private:
            // Should not be used by friends.
            static std::atomic<uint32_t>& getCounterInstance() {
                static std::atomic<uint32_t>  counter = 0;
                return counter;
            }

       public:
            // Handy access methods:
            static void incrementCounter() {
                ++getCounterInstance();
            }
            static void decrementCounter() {
                --getCounterInstance();
            }
    };
};

The only person that has access to incrementCounter() and decrementCounter() are members of countable.

You got the default constructor and the copy constructor.

    countable()
    {
        ++counter::s_counter;
    }

    countable(const countable&)
    {
        ++counter::s_counter;
    }

But you forgot the move constructor.

    countable(countable&&)
    {
        counter::incrementCounter();
    }

First of all, you can now make inline static data members, which is designed specifically for being able to make header-only libraries without needing a CPP file just to hold the point of definitions.

Your main usability issue is the need to make a different instantiation of the template for each class you want to count.

Note that your counter can be a member as well as a base class. So don’t make it look like CRTP, because it’s not. The template instantiation does not need to know about the derived class it is a base of. It is just a unique label.

Here is another way to do that:

using counter1 = counter<struct tag1>;

That is, you can declare a struct type right in the template argument.
You can also:

using counter1 = counter<counter1>;

refer to the (incomplete) name being declared, so you don’t need yet another unique symbol name. This is similar to your inheriting use — the class being declared is just a handy type name to use.

You should make sure all the housekeeping members are provided, as the class you put this in will only get (x) if all its members and bases do (x). You forgot some. So did Martin in his answer. See §15 for the authoritative list.

This has been taught as “The Rule of Five” but that neglects that any defined destructor will also kill auto-generation of move functions, so it should really be the Rule of Six. Or for movie fans, Rule of 5.1 perhaps?

You are making the constructors private and the intended derived class a friend? Isn’t that what protected is for?

Another thought — if you want to avoid accidentally providing names that the derived class will inherit and step on something, you can make the accessor a free function template instead of a member function.

But what about the static counter itself? It still has a name. Is there a way to put that outside but still distinct for each instantiation?

There is indeed an easy way to do that. Make a variable template!

template<typename Tag>
atomic<uint32_t> count;

I don’t think this is what you are looking for, though, since you want to prevent other code from manipulating the counter. So make the template variable a class.

Actually, the template variable is just a shortcut for a static data member of a template, and now it moves inside a class like you are used to:

template <typename Owner>
class counters {
    static inline atomic<uint32_t> count { 0 };
    friend class count_this<Owner>;
public:
    static uint32_t get() { return count; }
};

Then the instrumentation class contains just the special members, no other members.

template <typename Owner>
struct count_this {
    count_this() { ++counters<Owner>::count }
      ⋮

• This class can be simplified: there is no need for nested counter class as well as for friend declarations if proper access specifiers are used: private for s_counter and protected for all the constructors / destructor.

• This class would be more flexible of counter value type was supplied as a template parameter (with default value):

template<typename t_derived, typename t_counter = std::atomic<std::uint32_t>>
struct countable

• All functions here could make use of noexcept specifier.

• Putting more asserts could be helpful as well, for example at destructor:

~countable()
{
    assert(0 < counter::s_counter);
    --counter::s_counter;
}