c++ - resueltos - Pregunta de asignación de memoria dinámica

malloc y calloc

Question

cuando asigna memoria dinámica en el montón con un puntero,

char *buffer_heap = new char[15];

se representaría en la memoria como:

 ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍýýýý««««««««þþþ

¿Por qué no hay un carácter de terminación NULO al final en lugar de ýýýý «« «« «« «« þþþ?

Answer 1

Necesitas inicializarlo. Los tipos incorporados se pueden inicializar a cero llamando explícitamente al constructor predeterminado:

char *b = new char[15]();

Answer 2

No has inicializado esa memoria. Solo estás viendo lo que ya estaba allí ...

Answer 3

Porque char es un tipo nativo, no está inicializado. Así es C ++ (es un legado de C).

Simplemente acéptalo y terminalo tú mismo:

char *buffer_heap = new char[15];
*buffer_heap = ''/0'';

o si quiere que se inicialice todo el buffer:

std::fill(buffer, buffer + 15, 0);

Answer 4

Si bien cada cadena de estilo C se representa como una secuencia de caracteres, no todas las secuencias de caracteres son cadenas.

Normalmente, el / 0 aparece cuando asigna directamente un literal de cadena, o cuando lo agrega usted mismo. Y solo tiene sentido si trata esa matriz como una cadena con funciones que tienen en cuenta el / 0.

Si solo asigna la memoria y no la inicializa, está llena de elementos aleatorios. Puede haber un 0 allí o no, tendrás que poner algo significativo allí en un paso posterior. Depende de ti si quieres hacer que algo sea una cadena o no.

Answer 5

Solo se inicializará si asigna un tipo que se inicializó. De lo contrario, si quiere algunos valores significativos allí, tendrá que escribirlos en usted mismo.

Por otro lado, la mejor respuesta es que simplemente no deberías hacer esto en primer lugar. Olvídate de que existe new[] , y no mires atrás.

Answer 6

Í es byte 0xCD, que el asignador de depuración de Windows escribe en sus 15 bytes de memoria para indicar que se trata de una memoria de montón no inicializada. La pila no inicializada sería 0xCC. La idea es que si alguna vez lees la memoria e inesperadamente obtienes este valor, puedes pensar: "mmm, probablemente he olvidado inicializar esto". Además, si lo lee como un puntero y lo desreferencia, Windows bloqueará su proceso, mientras que si un buffer no inicializado estuviera lleno de valores aleatorios o arbitrarios, a veces por casualidad obtendría un puntero válido, y su código podría causar todo tipos de problemas C ++ no dice qué valores contiene la memoria no inicializada, y los asignaturas sin depuración no perderán tiempo llenando la memoria con valores especiales para cada asignación, por lo que nunca debe confiar en que ese valor esté allí.

Esto es seguido por 4 bytes de ý (byte 0xFD), que usa el asignador de depuración de Windows para indicar una región fuera de límites al final de un búfer. La idea es que si alguna vez te encuentras en el depurador escribiendo en una región que se ve así, puedes pensar "mmm, probablemente haya invadido mi memoria intermedia aquí". Además, si el valor ha cambiado cuando se libera el búfer, el asignador de memoria puede advertirle que su código es incorrecto.

«Es byte 0xAB y þ es 0xFE. Es de suponer que estos también tienen la intención de llamar la atención (no son punteros plausibles o compensaciones, por lo que no forman parte de la estructura del montón). No sé lo que significan, posiblemente más datos de guardia como el 0xFD.

Finalmente, supongo que ha encontrado un byte 0, el decimosexto byte más allá del final de su buffer de 15 bytes (es decir, el conteo del 31º byte desde el inicio).

Hacer la pregunta como "C ++" sin mencionar que estás en Windows sugiere que así es como se comporta C ++. No lo es, es cómo se comporta una implementación de C ++, con opciones de compilador particulares y / o DLL vinculados. C ++ no le permite leer más allá del final del búfer, Microsoft solo está siendo amable con usted y le permite salirse con la suya sin que se cuelgue o empeore.

Answer 7

En GNU C ++ (g ++) en Linux, este programa sale bastante rápido:

#include <algorithm>
#include <iterator>
#include <vector>
#include <cstddef>
#include <cstdlib>
#include <iostream>

namespace {

class rand_functor {
 public:
   int operator ()() const { return ::std::rand(); }
};

}

int main()
{
   using ::std::cout;
   using ::std::vector;
   using ::std::ostream_iterator;
   using ::std::generate;
   using ::std::equal;
   using ::std::copy;

   char *tmp = new char[1000];
   // This just fills a bunch of memory with random stuff, then deallocates it
   // in the hopes of making a match more likely.
   generate(tmp, tmp+1000, rand_functor());
   delete[] tmp;
   vector<char *> smalls;
   smalls.push_back(new char[15]);
   do {
      smalls.push_back(new char[15]);
   } while (equal(smalls[0], smalls[0]+15, smalls[smalls.size() - 1]));
   cout << "        In one allocation I got: [";
   copy(smalls[0], smalls[0]+15, ostream_iterator<char>(cout));
   cout << "]/nAnd in another allocation I got: [";
   copy(smalls[smalls.size() - 1], smalls[smalls.size() - 1]+15,
        ostream_iterator<char>(cout));
   cout << "]/n";
   cout << "It took " << smalls.size() << " allocations to find a non-matching one./n";
   return 0;
}