Почему нельзя разместить в стеке массив произвольного размера?

Это не имеет ничего общего с предотвращением переполнения стека, вы можете просто переполнить стек с помощью char a[SOME_LARGE_CONSTANT]. В C++ размер массива должен быть известен во время компиляции, это, среди прочего, необходимо для вычисления размера структур, содержащих массивы.

C, с другой стороны, имел массивы переменной длины с C99, что добавляет исключение и позволяет размер, зависящий от времени выполнения, для массивов в пределах области действия функции. Почему в С++ этого нет? Он никогда не был принят стандартом C++.

Почему я не могу написать следующее?

char acBuf[nSize];

Они называются массивами переменной длины (VLA) и не поддерживаются C++. Причина в том, что стек очень быстрый, но крошечный по сравнению с бесплатным магазином (куча, по вашим словам). Это означает, что в любой момент, когда вы добавляете много элементов в VLA, ваш стек может просто переполниться, и вы получите неопределенное исключение времени выполнения. Это также может произойти с массивами стека размером во время компиляции, но их легче поймать, потому что поведение программы не влияет на их размер. Это означает, что x не обязательно должно происходить после y, чтобы создать переполнение стека, это просто сразу же. Это описывает это более подробно и яростно.

Контейнеры, такие как std::vector, используют свободное хранилище, которое намного больше и имеет способ справиться с чрезмерным выделением (выдает bad_alloc).

В отличие от C, C++ не поддерживает массивы переменной длины. Если они вам нужны, вы можете использовать нестандартные расширения, такие как alloca или расширения GNU (поддерживается clang и GCC). У них есть свои предостережения, поэтому обязательно прочитайте руководство, чтобы убедиться, что вы используете их безопасно.

Причина, по которой расположение стека в основном определяется статически, заключается в том, что сгенерированный код должен выполнять меньше вычислений (сложения, умножения и разыменования указателя), чтобы выяснить, где находятся данные в стеке. Вместо этого смещения могут быть жестко закодированы в сгенерированном машинном коде.

Мой совет — взглянуть на alloca.h

   void *alloca(size_t size);

Функция alloca() выделяет size байтов пространства в кадре стека вызывающего объекта. Это временное пространство автоматически освобождается, когда функция, вызвавшая alloca(), возвращается к вызывающей стороне.

Одна возможная проблема, которую я вижу с VLA в C++, — это тип.

Какой тип acBuf в char acBuf[nSize] или еще хуже в char acBuf[nSize][nSize] ?

template <typename T> void foo(const T&);

void foo(int n)
{
    char mat[n][n];

    foo(mat);
}

Вы не можете передать этот массив по ссылке на

template <typename T, std::size_t N>
void foo_on_array(const T (&a)[N]);

Вы должны быть довольны тем, что стандарт C++ не одобряет опасную практику (массивы переменной длины в стеке) и вместо этого поощряет менее опасную практику (массивы переменной длины и std::vector с выделением кучи).

Массивы переменной длины в стеке более опасны, потому что:

• Доступное пространство стека обычно составляет 8 МБ, что намного меньше, чем 2 ГБ (или более) доступного пространства кучи.
• Когда пространство стека исчерпано, программа аварийно завершает работу с SIGSEGV, и для нее требуется специальное программное обеспечение, такое как GNU libsigsegv оправиться от такой ситуации.
• В типичных программах на C++ программист не знает, будет ли длина массива определенно оставаться ниже предела, такого как 4 МБ.

Почему я не могу написать следующее? char acBuf[nSize];

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

Если вы хотите создать динамический массив, вы должны использовать оператор new, чтобы он был сохранен в куче.

char *acBuf = new char[nsize];