Cómo encontrar la memoria utilizada por cualquier objeto

Question

class Help 
{ 
public: 
     Help(); 
     ~Help(); 

     typedef std::set<string> Terms; 
     typedef std::map<string, std::pair<int,Terms> > TermMap; 
     typedef std::multimap<int, string, greater<int> > TermsMap; 

private: 

     TermMap terms; 
     TermsMap termsMap; 
}; 

¿Cómo podemos encontrar la memoria utilizada (en bytes) por los objetos y termtermsMap. ¿Tenemos alguna biblioteca?

Answer 1

el operador sizeof() debería hacerlo:

size_t bytes = sizeof(Help::TermMap); 

Answer 2

Si usted está buscando para el bloque actual de la memoria, el valor numérico de un puntero a ella debe ser la misma. (Entonces solo agrega el número de bytes, y tienes el final del bloque).

Answer 3

Si está buscando el uso total de la memoria de un objeto, esto no se puede resolver en general en C++ - mientras que podemos obtener el tamaño de una instancia a través del sizeof(), el objeto siempre puede asignar memoria dinámicamente según sea necesario .

Si usted puede averiguar cuán grande es el elemento individual en un contenedor son, se puede obtener una cota inferior:

size = sizeof(map<type>) + sum_of_element_sizes; 

Tenga en cuenta sin embargo que los recipientes todavía pueden asignar memoria adicional como un detalle de implementación y que para contenedores como vector y string debe verificar el allocated size.

Answer 4

Respuesta corta: No

respuesta Largo:
-> El objeto básico sí. sizeof (<TIPO>) pero esto solo es útil para cosas limitadas.
-> un recipiente y sus miembros contenían: NO

Si hace suposiciones sobre las estructuras utilizadas para implementar estos objetos se puede estimar la misma. Pero incluso eso no es realmente útil (aparte del caso muy específico del vector).

Los diseñadores de la STL deliberadamente no definieron las estructuras de datos que deberían usar estos contenedores. Hay varias razones para esto, pero una de ellas (en mi opinión) es evitar que las personas hagan suposiciones sobre las partes internas y, por lo tanto, intentar hacer cosas tontas que no estén encapsuladas por la interfaz.

Entonces, la pregunta se reduce a por qué necesita saber el tamaño?
¿De verdad necesita saber el tamaño (poco probable pero posible).

¿O hay una tarea que intentas lograr donde crees que necesitas el tamaño?

Answer 5

¿Cómo podemos encontrar la memoria utilizada (en bytes) por el término objetos y termsMap. ¿Tenemos alguna biblioteca?

Debe usar su propio tipo de asignador.

typedef std::set<string, 
    your_allocator_1_that_can_count_memory_consumption_t> Terms; 

typedef std::map<string, std::pair<int,Terms>, 
    your_allocator_2_that_can_count_memory_consumption_t> TermMap; 

typedef std::multimap<int, string, greater<int>, 
    your_allocator_3_that_can_count_memory_consumption_t> TermsMap; 

que aún no han comprobado esta idea para std :: string lo que si es difícil de poner en práctica sólo tiene que utilizar su propio fixed_string clase que simplemente se envuelve s char [-serie-máx Longitud].

Y cuando se necesita en su programa para averiguar el consumo de memoria acaba de obtener de your_allocator_1_that_can_counts_memory_consumption_t, your_allocator_2_that_can_counts_memory_consumption_t, your_allocator_3_that_can_counts_memory_consumption_t.

Editado

Para UncleBens quiero aclarar mi punto.

Por lo que entiendo por la cuestión del ARV, es necesario saber cuánta memoria se asigna para set :: set y std :: map, incluida toda la memoria asignada para los elementos del conjunto y el mapa. Entonces no es solo sizeof (términos).

Así que acabo de sugerir un asignador muy simple. Sin entrar en demasiados detalles que podría tener este aspecto:

template <class T> 
class your_allocator_1_that_can_counts_memory_consumption_t { 
public: 
    // interfaces that are required by the standart 
private: 
    std::allocator<T> std_allocator_; 
    // here you need to put your variable to count bytes 
    size_t globale_variable_for_allocator_1_to_count_bytes_; 
}; 

Este asignador simplemente cuenta el número de bytes asignados y desasignado y para la asignación real y cancelación de asignación utilice su std_allocator_ miembro. Necesitaría depurarlo bajo gdb para establecer un punto de interrupción en malloc() y en free() para asegurarme de que cada asignación y desasignación en realidad pasan por mi asignador.

Estaría agradecido si me señala algunos problemas con esta idea ya que ya la he implementado en mi programa que se ejecuta en Windows, Linux y HP-UX y simplemente pregunto mis asignaturas para encontrar cuánta memoria cada uno de mis contenedores usa