Almacenar objetos en el vector STL - conjunto mínimo de métodos

Question

¿Qué es el "marco mínimo" (métodos necesarios) del objeto complejo (con datos internos mal explícitamente), que quiero almacenar en el contenedor STL, p. <vector>?

Para mis supuestos (ejemplo de objeto complejo Doit):

#include <vector> 
#include <cstring> 
using namespace std; 
class Doit { 
    private: 
     char *a; 
    public: 
     Doit(){a=(char*)malloc(10);} 
     ~Doit(){free(a);} 
}; 

int main(){ 
    vector<Doit> v(10); 
} 

da

*** glibc detected *** ./a.out: double free or corruption (fasttop): 0x0804b008 *** 
Aborted 

y en valgrind:

malloc/free: 2 allocs, 12 frees, 50 bytes allocated. 

UPDATE:

métodos mínimos para tal obj ect son: (basado en la respuesta OSE)

class DoIt{ 
    private: 
     char *a; 
    public: 
     DoIt() { a=new char[10]; } 
     ~DoIt() { delete[] a; } 
     DoIt(const DoIt& rhs) { a=new char[10]; std::copy(rhs.a,rhs.a+10,a); } 
     DoIt& operator=(const DoIt& rhs) { DoIt tmp(rhs); swap(tmp); return *this;} 
     void swap(DoIt& rhs) { std::swap(a,rhs.a); } 
}; 

Gracias, OSE, https://stackoverflow.com/users/140719/sbi

Answer 1

Tenga en cuenta que Charles tiene answered your question perfectamente.

De todos modos, según el Rule of Three, su clase, que tiene un destructor, también debe tener un constructor de copia y un operador de asignación.

Así es como yo lo haría:

class Doit { 
    private: 
     char *a; 
    public: 
     Doit()     : a(new char[10]) {} 
     ~Doit()     {delete[] a;} 
     DoIt(const DoIt& rhs) : a(new char[10]) {std::copy(rhs.a,rhs.a+10,a);} 
     void swap(DoIt& rhs)  {std::swap(a,rhs.a);} 
     DoIt& operator=(DoIt rhs) {swap(rhs); return *this;} 
}; 

Answer 2

Todo vector requiere es que el objeto es "asignable", lo que significa que necesita un constructor de copia, destructor, y el operador de asignación, todos ellos generados de forma predeterminada si no los proporciona usted mismo.

Como dice sbi, si necesita una de esas funciones, probablemente las necesite todas. En su caso, también deberá proporcionar un constructor de copias y un operador de asignación para evitar daños en el montón.

Answer 3

Todos los tipos que use deben ser CopyConstructible y Assignable.

CopyConstructible para un tipo T significa que si t es una T o una const T entonces la expresión T(t) debe producir un equivalente T a la original t; t. ~ T() debe ser válido (destructor accesible); y &t debe dar la dirección de t como [const] T*.

Assignable significa que para un T, t y un valor uT, la expresión t = u debe hacer t equivalente a u y ser de tipo T&.

Tenga en cuenta que todos estos requisitos se cumplen mediante simples tipos incorporados y estructuras POD. Si hace algo no trivial en un destructor o constructor, debe asegurarse de que el constructor de copias y el operador de asignación de copias conservan la semántica de equivalencia.