Buenas, repasando el tema de los destructores me he topado con un bache, algo que intuyo que es provocado por std::vector, me explico:

Tengo una clase "Padre" con un vector de clases "Hijos", cada clase Hijo tiene un destructor que indica la "muerte" de ésta. A partir del código que publico a continuación, esperaba que ningún hijo muriese a no ser que le aplique un delete o el programa finalizase, pero no es así.
Cada vez que hago un push_back a un Hijo desde la clase Padre, los Hijos que ya habían anteriormente en el vector son destruidos, ¿por qué?  

Mirando la documentación oficial de std::vector::push_back, me encuentro con:


Por lo que entiendo de ahí, el hecho de reubicar memoria, podría causar que se destruya la clase Hijo del vector y se vuelva a construir, pero si así fuese, ¿por qué no se ejecuta el cout que notifica que ha nacido la clase Hijo?


class.hpp

#include <iostream>
#include <vector>
using namespace std;
 
class Child
{
    string name;
public:
    Child(string);
    ~Child();
    string getName();
};
 
class Father
{
    vector<Child> children;
public:
    void addChild(Child*);
    void showNames();
};

class.cpp

#include "class.hpp"
 
Child::Child(string n) : name(n)
{
    cout << "Ha nacido " << name << "." << endl;
}
 
Child::~Child()
{
    cout << "Ha muerto " << name << "." << endl;
}
 
string Child::getName()
{
    return name;
}
 
void Father::addChild(Child *c)
{
    cout << c->getName() << " ha sido adoptado." << endl;
    children.push_back(*c);
}
 
void Father::showNames()
{
    for(unsigned int i=0; i<children.size(); i++)
    {
        cout << "Hijo #" << i << ": " << children.at(i).getName() << endl;
    }
}

main.cpp

#include "class.hpp"
 
int main(int argc, char *argv[])
{
    Child *c1, *c2, *c3;
    c1 = new Child("Juan");
    c2 = new Child("Lucas");
    c3 = new Child("Antonio");
 
    Father f1;
 
    cout << "---" << endl;
    f1.addChild(c1);
    cout << "---" << endl;
    f1.addChild(c2);
    cout << "---" << endl;
    f1.addChild(c3);
    cout << "---" << endl;
 
    f1.showNames();
 
    delete c2;
    delete c3;
 
    f1.showNames();
 
    cout << "---" << endl;
    return 0;
}

Output

Mientras creaba este post, me he dado cuenta de que estaba haciendo un vector de Hijos (vector<Child>), cuando lo que quería hacer es un vector de punteros a clases Hijos (vector<Child*>).
Ésto soluciona el programa que arriba expongo, pero sigo con la duda de por qué, si no es un vector de punteros, ocurre lo arriba explicado.

Aparte de esta duda, una de las metas de éste código es que al hacerle delete a una clase Hijo, ésta sea borrada del vector<Hijos> de la clase Padre, cosa que creo que no es posible hacer directamente, (o tal vez sí, por eso pregunto), de no ser posible, agradecería cualquier método de "actualización", "verificación" o similar, que detecte que un miembro del vector de punteros ha sido borrado, y también debe ser borrado del vector... No sé si me explico. :X

Saludos

Esto no te influye, el recolocamiento es completamente transparente.

El problema esque estás creando copiando los objetos cada vez que haces push_back, por eso al hacer esto:

delete c2;
delete c3;

No tiene ningún efecto, tienes que usar punteros para apuntar a estos objetos:

vector<Child*> children;

Los mensajes del destructor no vienen del push_back sino de los delete que has puesto.

Mm... Pues vaya sorpresa  

He hecho una miniprueba:

#include <iostream>
#include <vector>
 
class A
{
   public:
    int cosa;
 
    A(int i) : cosa(i) { std::cout<<"Constructor invocado: "<<i<<std::endl;}
    A(const A & b){std::cout<<"Constructor copia invocado: "<<b.cosa<<std::endl; this->cosa = b.cosa;}
    ~A() { std::cout<<"Destructor invocado: "<<cosa<<std::endl;}
};
int main()
{
    A Buffer[5] { 0,1,2,3,4};
    std::vector<A> Cosas;
    std::cout<<"Empezando... "<<std::endl<<std::endl;
 
    for (short i = 0; i < 5;i++)
        Cosas.push_back(Buffer[i]);
 
    std::cin.get();
    return 0;
}

Te va diciendo los objetos que se van destruyendo, se construyen o se copian... Al parecer a partir de los 3 objetos, el vector intenta recolocar la memoria y para ello tiene que destruir los objetos y volverlos a construir en otra parte.

Pues parece que tenías razón  . Por curiosidad hice la prueba con listas:

#include <iostream>
#include <list>
 
class A
{
   public:
    int cosa;
 
    A(int i) : cosa(i) { std::cout<<"Constructor invocado: "<<i<<std::endl;}
    A(const A & b){std::cout<<"Constructor copia invocado: "<<b.cosa<<std::endl; this->cosa = b.cosa;}
    ~A() { std::cout<<"Destructor invocado: "<<cosa<<std::endl;}
};
int main()
{
    A Buffer[5] { 0,1,2,3,4};
    std::list<A> Cosas;
    std::cout<<"Empezando... "<<std::endl<<std::endl;
 
    for (short i = 0; i < 5;i++)
        Cosas.push_back(Buffer[i]);
 
    std::cin.get();
    return 0;
}

Aquí no pasa, de modo que está claro que es por el realloc() que se hace.

@amchacon: mm, cierto, no recordaba eso del constructor copia, eso era lo que no encajaba en mi teoría, lo que no entiendo es el orden en el que se van copiando y destruyendo los elementos, pero bueno, supongo que dependerá de los bloques de memoria que hayan libres y tal, así que mejor no darle más vueltas. Gracias por la aclaración.

@0xDani: Sí, gracias, aunque la verdad es que ya había pensado en ese método, pero antes de desarrollarlo quise dar un paso más y hacerlo de forma más directa, suelo darle muchas vueltas a todo para hacerlo de la forma más eficiente posible. De cualquier forma, el método funciona y puedo trabajar con él.

Gracias a ambos y un saludo!