Quelle est la bonne manière de libérer un vecteur std :: de pointeurs en C ++?

Le meilleur moyen est de ne pas mettre les pointeurs dans le vecteur, en premier lieu, si vous n'avez pas absolument besoin de.

Mais si vous ne vraiment besoin d'avoir un vecteur de pointeurs, puis de la façon dont vous le faites est très bien (mais .clear() le vecteur par la suite, si elle ne peut pas être immédiatement détruit, de sorte qu'il n'est pas plein de pendre des pointeurs)

La déclaration

delete *it;

n'a aucun effet sur l'itérateur. Il ne modifie pas l'itérateur, la nullité de l'itérateur, ou supprimer le pointeur de visée par l'itérateur de la collection. Il n'est de libérer de la mémoire, que le pointeur de visée par l'itérateur points. Le pointeur lui-même doit être retirée de la collection séparément.

Un autre C++ façon de le faire est de définir une aide struct:

struct delete_ptr { //Helper function to ease cleanup of container
    template <typename P>
    void operator () (P p) {
        delete p;
    }
};

et ensuite utiliser les algorithmes:

std::for_each(vector_day.begin(), vector_day.end(), delete_ptr());
vector_day.clear();

Vous devriez probablement utiliser une sorte de géré pointeur, le plus probable d'un pointeur partagé.

Si vous supprimez le vecteur tandis que quelqu'un d'autre est toujours tenue à l'un de ces pointeurs, vous allez obtenir quelques très méchant comportement s'ils essaient de les déréférencer. Un pointeur partagé permettra d'économiser vous que les maux de tête.

Si vous pouvez garantir que rien d'autre ne référence les pointeurs après le vecteur est supprimé, vous pouvez encore bénéficier de l'aide d'un pointeur automatique. Il faudra gérer de libération de la mémoire pour vous lorsque le vecteur est détruit. La surcharge est minime, et il rend votre vie beaucoup plus facile.

Tout d'abord, vous avez changé de i à itmais je suppose que c'est juste une faute de frappe.

Mais pour répondre à votre quête, non, c'est bien. Vous n'êtes pas changer itvous sont en train de changer *it.

Voici une pratique de classe, j'ai écrit tout à l'heure tout en traitant de la même question. J'ai été la conversion d'une partie du code de la vieille RogueWave basés sur des vecteurs et des listes jusqu'à la STL en fonction des vecteurs et des listes, et avaient besoin d'un moyen d'émuler RW clearAndDestroy() la méthode de pointeur listes. Le clearAndDestroy() la méthode peut être remplacée pour traiter les différents types de structure (je n'inclus vecteur ici par souci de concision).

class StlUtils
{
   public:

      /**
       * This method provides a templated way to destroy a std::vector
       * full of pointers.  It is basically a replacement for the RW
       * vector class' clearAndDestroy methods.  The list argument is
       * returned empty.
       *
       * @param list the list of pointers to be destroyed.
       */
      template<class T> static void clearAndDestroy(
         std::vector<T*> &itemList)
      {
         for_each(itemList.begin(), itemList.end(),
                  stl_deleter<T>());
         itemList.clear();
      }

   private:

      /**
       * Templated member function for use with the clearAndDestroy()
       * method.  It provides the method needed by for_each to do the
       * actual deletion.
       */
      template<class T> struct stl_deleter
      {
         void operator() (T* x) {
            if (x != NULL)
               delete x;
         }
      };
};