Вопрос о динамическом выделении памяти

Í — это байт 0xCD, который распределитель отладки Windows записывает в ваши 15 байтов памяти, чтобы указать, что это неинициализированная динамическая память. Неинициализированный стек будет 0xCC. Идея состоит в том, что если вы когда-нибудь читаете память и неожиданно получаете это значение, вы можете подумать про себя: «Хм, я, наверное, забыл инициализировать это». Кроме того, если вы прочитаете его как указатель и разыменуете его, то Windows разрушит ваш процесс, тогда как если неинициализированный буфер был заполнен случайными или произвольными значениями, то иногда по счастливой случайности вы получите действительный указатель, и ваш код может вызвать все виды неприятностей. C++ не говорит, какие значения содержит неинициализированная память, а неотладочные распределители памяти не будут тратить время на заполнение памяти специальными значениями для каждого выделения, поэтому вы никогда не должны полагаться на это значение.

Далее следуют 4 байта ý (байт 0xFD), которые распределитель отладки Windows использует для указания области за пределами буфера в конце буфера. Идея состоит в том, что если вы когда-нибудь обнаружите, что в отладчике вы пишете в область, которая выглядит так, вы можете подумать: «Хм, я, вероятно, переполнил свой буфер здесь». Кроме того, если значение изменилось при освобождении буфера, распределитель памяти может предупредить вас о том, что ваш код неверен.

« — байт 0xAB, а þ — 0xFE. Предположительно, они также предназначены для привлечения внимания (они не являются правдоподобными указателями или смещениями, поэтому они не являются частью структуры кучи). Я не знаю, что они означают, возможно, больше защитных данных, таких как 0xFD.

Наконец, я думаю, вы нашли 0 байт, 16-й байт после конца вашего 15-байтового буфера (т.е. 31-й байт, считая от его начала).

Задавая вопрос как «С++», не упоминая, что вы работаете в Windows, вы предполагаете, что именно так ведет себя С++. Это не так, это то, как ведет себя одна реализация C++ с определенными параметрами компилятора и/или связанными DLL. C++ не позволяет вам читать дальше конца буфера, Microsoft просто любезен с вами и позволяет вам избежать сбоев или чего-то похуже.

Вы не инициализировали эту память. Вы просто видите то, что уже было...

Вам нужно его инициализировать. Встроенные типы можно инициализировать нулем, явно вызвав конструктор по умолчанию:

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

Хотя каждая строка стиля C представлена ​​как последовательность символов, не каждая последовательность символов является строкой.

\0 обычно появляется, когда вы напрямую назначаете строковый литерал или когда вы добавляете его туда самостоятельно. И это имеет смысл только в том случае, если вы рассматриваете этот массив как строку с функциями, которые учитывают \0.

Если вы просто выделяете память и не инициализируете ее, она заполнена случайными вещами. Там может быть 0, а может и не быть — вам придется поместить туда что-то значимое на следующем шаге. Вам решать, делать ли это что-то строкой или нет.

Поскольку char является родным типом, он не инициализирован. Именно таков C++ (это наследие C).

Просто примите это и завершите это самостоятельно:

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

или если вы хотите инициализировать весь буфер:

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

Он будет инициализирован только в том случае, если вы выделите инициализированный тип. В противном случае, если вам нужны какие-то значимые значения, вам придется записать их в себя.

С другой стороны, лучший ответ заключается в том, что вам просто не следует этого делать. Забудьте, что new[] существует, и не оглядывайтесь назад.

В GNU C++ (g++) в Linux эта программа завершается довольно быстро:

#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;
}