La plus simple façon de compter les occurrences d'un objet

Ont un "compté objet" de la classe qui fait le calcul de référence approprié dans son constructeur(s) et le destructeur, alors déduire de vos objets que vous souhaitez suivre à partir d'elle. Vous pouvez ensuite utiliser l'curieusement récurrents de modèle de modèle pour obtenir des comptes distincts pour tous les types d'objet que vous souhaitez suivre.

//warning: pseudo code

template <class Obj>
class CountedObj
{
public:
   CountedObj() {++total_;}
   CountedObj(const CountedObj& obj) {if(this != &obj) ++total_;}
   ~CountedObj() { --total_;}

   static size_t OustandingObjects() {return total_;}

private:
   static size_t total_;
};

class MyClass : private CountedObj<MyClass>
{};

vous pouvez appliquer cette approche

#ifdef DEBUG

class ObjectCount {
    static int count;
  protected:
    ObjectCount() {
        count++;
    }
  public:
    void static showCount() {
        cout << count;
    }
};

int ObjectCount::count = 0;


class Employee : public ObjectCount {
#else
class Employee {
#endif
  public:
    Employee(){}
    Employee(const Employee & emp) {

    }
};

à DEBUG mode, en invoquant de ObjectCount::showCount() méthode retourne compter de l'objet créé(s)

Sans connaître votre code et de vos exigences, je vois 2 options raisonnables:

a) Utiliser boost::shared_ptr. Il a la atomique, le nombre de références que vous avez suggéré intégré et prend en charge votre gestion de la mémoire (de sorte que vous n'avais jamais réellement soin de regarder le comte). Son nombre de références est disponible par le biais de la use_count() membre.

b) Si les conséquences d'un), par exemple en présence de pointeurs et d'avoir shared_ptrs partout, ou possible des performances, ne sont pas acceptables pour vous, je vous suggère de simplement utiliser les outils disponibles pour la mémoire de détection de fuite (par exemple Valgrind, voir ci-dessus) qui va déclarer vos objets en vrac à la sortie du programme. Et il n'y a pas besoin d'utiliser intrusif des classes d'aide pour (de toute façon de débogage uniquement) suivi des décomptes d'objet, qui vient de gâcher votre code, à mon humble avis.

Mon approche, qui sort de fuite à compter de la Sortie de Débogage (via le DebugPrint fonction implémentée dans notre base de code, remplacez-la avec votre propre...)

#include <typeinfo> 
#include <string.h>
class CountedObjImpl
{
public:
        CountedObjImpl(const char* className) : mClassName(className) {}
        ~CountedObjImpl()
        {
                DebugPrint(_T("**##** Leakage count for %hs: %Iu\n"), mClassName.c_str(), mInstanceCount);
        }
        size_t& GetCounter() 
        {
                return mInstanceCount;
        }

private:
        size_t mInstanceCount = 0;
        std::string mClassName;
};

template <class Obj>
class CountedObj
{
public:
        CountedObj() { GetCounter()++; }
        CountedObj(const CountedObj& obj) { GetCounter()++; }
        ~CountedObj() { GetCounter()--; }

        static size_t OustandingObjects() { return GetCounter(); }

private:
        size_t& GetCounter()
        {
                static CountedObjImpl mCountedObjImpl(typeid(Obj).name());
                return mCountedObjImpl.GetCounter();
        }
};

Exemple d'utilisation:

class PostLoadInfoPostLoadCB : public PostLoadCallback, private CountedObj<PostLoadInfoPostLoadCB>