С++ выделение памяти new

Память под статический массив по стандарту резервируется в программном стеке во время компиляции, который ограничен размером, как правило это два мегабайта, но может быть и больше. Память, которая резервируется под статические массивы в одной области видимости – суммируется, и это следует учитывать. Размер статического массива должен быть известен к началу компиляции. Во время выполнения программы изменить размер статического массива невозможно. Память, выделяемая под динамический массив выделяется непрерывным куском в куче и ограничена ресурсами оперативной памяти. Размер динамического массива можно изменять во время выполнения программы.

К ответу двумя этажами выше. Оператор new не является синтаксическим сахаром, так как в отличии от malloc (calloc, realloc) вызывает конструкторы объектов, ну а delete, в отличие от free – вызывает деструкторы. Операторы new, new[], delete и delete[] можно перегружать, создавая собственные аллокаторы. Это тема большая и сложная. Здесь подробнее об этом.

Память выделенная c использованием malloc (calloc, realloc) должна освобождаться вызовом free, а выделенная с использованием new (new[]), освобождается вызовом delete (delete[]). Освобождать память выделенную динамически следует обязательно, а указателю, по которому она была выделена следует присвоить nullptr (NULL). Перед вызовом delete (delete[]) либо free следует проверять указатель на существование

 if (ptr != nullptr) {

    delete ptr;

    ptr = nullptr;

} 

 if (matrix != nullptr) { 

    for (size_t i = 0; i < length; ++i) delete[] matrix[i];

    delete[] matrix;

    matrix = nullptr; 

} 

 if (ptr != NULL) { 

    free(ptr); 

    ptr = NULL; 

} 

Память под статический массив освобождается автоматически после завершения блока кода в котором она была выделена.

Любые попытки непредусмотренного стандартом вызова malloc, calloc, realloc, new, new[], delete, delete[], free могут привести к неопределённому поведению

int *a=new int[5]; - массив можно создавать нужного размера по ходу выполнения функции и уничтожать во время ее работы.
int a[5] - массив создается при загрузке кода функции и не может быть в ней уничтожен. Зато его можно инициализировать при объявлении. delete к нему применять нельзя.
Кроме того, есть разница в максимально допустимой длине. Еще одна разница (последовательное или вразброс размещение подмассивов) появится, если перейти к многомерным массивам.

 int a[5] // cтатический массив  

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

 int b[5] = {1,2,3,4,5} // любые целые числа  

 

int* a = new int[5]; // динамический массив  

память для динамического массива выделяется
при выполнении программы.
Поэтому размер исполнимого файла не
увеличивается.
Это актуально для больших массивов,
или массивов, размер которых
заранее неизвестен.

new - это в некотором роде синтаксический
сахар к классическим сишным функциям
alloc, malloc,
хотя механизм вполне удобный

Все тут ошиблись.
int a[5] означает только 5 (4х (обычно) байтных) переменных расположенных непрерывно. То есть это просто одна большая переменная. И в зависимости от того где она обьявлена, она может быть либо автоматической либо глобальной либо динамической)

вот и int* a = new int[5]; //обратите особое внимание на запись int[5] - это и есть ваш a[5].
new разместит эту переменную где-то в динамической памяти.
int a[5]; вне функций или внутри но с пометкой static сделает ее глобальной.
В остальных случаях она (массивина эта) будет обычной автоматической переменной.

И вообще массивов не существует.
(есть еще только для чтения переменные, например строки текста (чем не массив)? И расположены они вообще в постоянной неизменяемой области памяти)

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

>delete можно применить как к int a[5];
Применение delete к стековому массиву - это неопределённое поведение и за такое даже по ушам давать мало.

Основное различие между int a[5] и int* a = new int[5] заключается в том, как память выделяется и освобождается. Когда вы объявляете int a[5], память для массива выделяется на стеке, а когда вы используете int* a = new int[5], память выделяется в куче.

Оператор delete используется для освобождения памяти, которая была выделена с помощью оператора new. Он не может использоваться для освобождения памяти, которая была выделена на стеке. Таким образом, вы можете использовать delete для освобождения памяти, которая была выделена с помощью int* a = new int[5], но не можете использовать его для освобождения памяти, которая была выделена с помощью int a[5].

Важно отметить, что когда вы используете оператор new для выделения памяти, это ваша ответственность как программиста освободить эту память с помощью оператора delete, когда она больше не нужна. Если вы не освободите эту память, это может привести к утечке памяти. В то же время, когда вы используете массивы, объявленные на стеке, такие как int a[5], память автоматически освобождается, когда массив выходит из области видимости.

Наверно ни в чем. Типо кому как удобней писать. А лучше спроси у нейронки от яндекса она програмирование знает, что хочешь подскажет. ну или you ком так и называется еще какая то есть не помню но на них только английский язык