3
So, nach nun einer Stunde Überlegen hab ich so ziemlich alles umgekrempelt. Das Problem mit dem bisherigen Ansatz ist, dass er mit Vererbungshierarchien nicht zurechtkommt. Beispiel: 2 Klassen base und derived, beide ebenfalls von tracked<T> abgeleitet. In dervied wäre object_count nun ambigious.
Der neue Ansatz düfte mit allen denkbaren Hierarchien funktionieren.
template <typename>
std::size_t object_count();
template <typename Derived>
struct tracked
{
friend std::size_t object_count<Derived>();
protected:
tracked() { ++object_count; }
tracked(tracked const&) { ++object_count; }
~tracked() { --object_count; }
private:
static std::atomic_size_t object_count;
};
template <typename Derived>
std::atomic_size_t tracked<Derived>::object_count;
template <typename T>
std::size_t object_count()
{
static_assert(std::is_base_of<tracked<T>, T>::value, "instances of this type are not tracked");
return tracked<T>::object_count;
}
object_count ist nun zu einer freien Funktion geworden. Außerdem hat die Klasse tracked keine public Member mehr, was bedeutet, dass man auch einfach private von ihr erben kann und sie somit nicht mehr in ein tracked konvertierbar ist.
Verwendet sich dann so:
struct base : private tracked<base> {};
struct derived : base, private tracked<derived> {};
int main()
{
derived d;
std::cout << object_count<base>() << '\n'
<< object_count<derived>() << '\n';
}
http://ideone.com/ltR7q
Gar nicht mal so einfach, wenn man es ordentlich machen will.