Des objets de transaction stockés dans un vecteur?

en C ++, vous ne pouvez supprimer que des données par pointeur. Vous avez accompli cela à l'aide de l'opérateur & opérateur, mais si votre vecteur ne contient pas de pointeurs qui indiquent la mémoire allouée sur le tas de machines (pas la pile, de même que la méthode lorsque vous avez une déclaration de variable normale), vous pouvez essayer de Supprimez-le, mais vous rencontrerez un comportement indéfini (qui saura causer un crash de programme).

Lorsque vous insérez dans un vecteur, le vecteur appelle le constructeur de copie de la classe et vous insérez réellement une copie de l'objet. Si vous avez une fonction dont le seul but est comme suit: p> xxx pré>

se rend compte qu'il y a deux em> obj dans cette lunette: celle que vous avez passée en référence, et la copie dans le vecteur. Si nous avons eu lieu à la place de MyObject par valeur et non par référence, nous pourrions dire que deux copies de l'objet existent dans cette portée et une existence dans l'appelant. Dans chacune de ces 3 instances, ils sont pas em> le même objet. P>

Si vous stockez plutôt des pointeurs dans le conteneur, le vecteur créera une copie du pointeur ( pas em> une copie de l'objet) et insérera le pointeur copié dans le vecteur. Ce n'est généralement pas une bonne pratique d'insérer des éléments dans un conteneur par pointeur, à moins que vous ne em> ne connaisse em> que l'objet vivra au moins jusqu'à ce que le conteneur soit effectué. Par exemple, p>

void insert()
{
  Obj myObj;
  myVector.insert(&myObj);
}

Il est difficile de dire à la terminologie que vous avez utilisée et que le code présenté exactement ce qui se passe. Donc, peut-être que quelques exemples vous aideraient à sortir.

Array Nouveau et matrice Supprimer h2>

Quoi de neuf avec Nouveau [] code> et Suppr [] code> vous interroger? Ces gars sont utilisés pour allouer / distribuer des tableaux de choses. Ces choses pourraient être une pod ou ils pourraient être des objets pleins foutus. Pour les objets, ils appelleront le constructeur après l'allocation et la destructeur tout en traçant. P>

Prenons un exemple artificiel: P>

for (size_t idx = 0; idx < a_vector_of_pointers.size(); idx++) {
   delete a_vector_of_pointers[idx];
}

Il est difficile de dire de votre question juste quelle est la signature de mapper code> est. Je suppose que vous souhaitez utiliser Suppr [] code> car vous avez également utilisé nouveau [] code>. Cela signifie-t-il que les membres de votre vecteur sont eux-mêmes une collection? Supposant que ce soit, alors vous avez quelque chose comme ceci:

class Building {
  public:
    typedef std::vector<int> maps_t;
  private:
    std::vector<maps_t> maps;
  public:
    Building();
};

Building::Building(size_t num_maps) {
  for(;num_maps; --num_maps)
  {
    maps.push_back(Building::maps_t(10));  
  }
}

for(std::vector<MyObjectClass>::iterator beg = myVector->begin(), end = myVector->end(); beg != end; beg++)
{
    delete *beg;
}
myVector->clear();

J'ai décidé de transformer mon commentaire en une réponse (avec les autres grandes réponses ici), alors c'est ici.

Je remarquerais à nouveau que cette affaire traite de l'héritage de l'objet. P> Lorsque vous supprimez une matrice d'objet dérivé, indiquée par un pointeur de base, comme suit: p> xxx pré>

ce que le compilateur "sous la hotte" est de générer le code suivant : P>

#include <iostream>
using namespace std;

class Base 
{

    public:
        Base(int a, int b)
        : m_a(a)
        , m_b(b)    
        {
           cout << "Base::Base - setting m_a:" << m_a << " m_b:" << m_b << endl;
        }

        virtual ~Base()
        {
            cout << "Base::~Base" << endl;
        }

        protected:
            int m_a;
            int m_b;
};


class Derived : public Base
{
    public:
    Derived() 
    : Base(1, 2) , m_c(3)   
    {

    }

    virtual ~Derived()
    {
        cout << "Derived::Derived" << endl;
    }

    private:    
    int m_c;
};

int main(int argc, char** argv)
{
    // create an array of Derived object and point them with a Base pointer
    Base* pArr = new Derived [3];

    // now go ahead and delete the array using the "usual" delete notation for an array
    delete [] pArr;

    return 0;
}