Статический массив против динамического массива в С++

Ответ 1

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

int foo[10];

Массивы, созданные с помощью operator new[], имеют динамическую продолжительность хранения и хранятся в куче (технически "свободный магазин" ). Они могут иметь любой размер, но вам нужно выделять и освобождать их самостоятельно, так как они не являются частью фрейма стека:

int* foo = new int[10];
delete[] foo;

Ответ 2

static - это ключевое слово в C и С++, поэтому вместо общего описательного термина static имеет очень специфическое значение при применении к переменной или массиву. Чтобы усугубить путаницу, он имеет три разных значения в отдельных контекстах. Из-за этого статический массив может быть как фиксированным, так и динамическим.

Позвольте мне объяснить:

Первый - это С++:

• Статический член класса - это значение, которое не создается с помощью конструктора или не удаляется деструктором. Это означает, что элемент должен быть инициализирован и поддерживаться каким-либо другим способом. статический член может быть указателем, инициализированным нулем, а затем назначается при первом вызове конструктора. (Да, это было бы статическим и динамическим).

Два наследуются от C:

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

• статические переменные, объявленные вне функций, являются глобальными переменными, доступ к которым возможен только из одного модуля (исходный код с любыми другими # include)

Вопрос (я думаю), который вы хотели задать, - это разница между динамическими массивами и фиксированными или компиляционными массивами. Это более простой вопрос: массивы времени компиляции определяются заранее (когда компиляция программы) и являются частью фрейма стека функций. Они выделяются до запуска основной функции. динамические массивы выделяются во время выполнения с помощью "нового" ключевого слова (или семейства malloc из C), и их размер неизвестен заранее. динамические распределения не будут автоматически очищены до тех пор, пока программа не перестанет работать.

Ответ 3

Я думаю, что семантика, используемая в вашем классе, сбивает с толку. Что, вероятно, подразумевается под "static", это просто "постоянный размер", и что, вероятно, подразумевается под "динамическим", это "переменный размер". В этом случае массив с постоянным размером может выглядеть так:

int x[10];

а "динамический" - это любая структура, которая позволяет увеличить или уменьшить базовое хранилище во время выполнения. В большинстве случаев класс std::vector из стандартной библиотеки С++ будет достаточным. Используйте его так:

std::vector<int> x(10); // this starts with 10 elements, but the vector can be resized.

std::vector имеет operator[], поэтому вы можете использовать его с той же семантикой, что и массив.

Ответ 4

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

int arr[] = { 1, 3, 4 }; // static integer array.   
int* arr = new int[3]; // dynamic integer array.

Ответ 5

Я думаю, что в этом контексте это означает, что он статичен в том смысле, что размер исправлен. Используйте std::vector. Он имеет функцию resize().

Ответ 6

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

Статические переменные - это переменные, определенные с помощью статического распределения памяти, Это общая концепция, не зависящая от C/С++. В C/С++ мы можем создавать статические переменные с глобальной, файловой или локальной областью:

int x[10]; //static array with global scope
static int y[10]; //static array with file scope
foo() {
    static int z[10]; //static array with local scope

Автоматические переменные обычно реализуются с использованием распределения памяти на основе стека. Автоматический массив может быть создан в C/С++ следующим образом:

foo() {
    int w[10]; //automatic array

Что объединяет эти массивы, x, y, z и w, так это то, что размер для каждого из них является фиксированным и определяется во время компиляции.

Одна из причин, по которой важно понять различие между автоматическим массивом и статическим массивом, заключается в том, что статическое хранилище обычно реализуется в разделе данных (или раздел BSS) объектного файла, и компилятор может использовать абсолютные адреса для доступа к массивам, что невозможно в хранилище на основе стека.

Что обычно подразумевается под динамическим массивом, не является изменяемым по размеру, но реализовано с помощью динамическое распределение памяти с фиксированным размером, определенным во время выполнения. В С++ это делается с помощью оператора new.

foo() {
   int *d = new int[n]; //dynamically allocated array with size n     

Но возможно создать автоматический массив с размером исправлений, определенным во время выполнения, с помощью alloca:

foo() {
    int *s = (int*)alloca(n*sizeof(int))

Для истинного динамического массива следует использовать что-то вроде std::vector в С++ (или массив переменной длины в C).

Что означало назначение в вопросе ОП? Я думаю, ясно, что желаемый не был статическим или автоматическим массивом, а использовался для распределения динамической памяти с помощью оператора new или массива нефиксированного размера, например, std::vector.

Ответ 7

Да, правильный статический массив создается во время компиляции, когда динамический массив создается во время выполнения. Где, поскольку разница до сих пор связана с их ячейками памяти, статические находятся в стеке, а динамика создается в куче. Все, что попадает в кучу, требует управления памятью до тех пор, пока не появится сборщик мусора, как в случае .net framework, иначе существует риск утечки памяти.

Ответ 8

Статический массив: эффективность. Динамическое распределение или освобождение не требуется.

Массивы, объявленные в функции C, С++, включая статический модификатор, являются статическими. Пример: static int foo [5];

Ответ 9

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

int size;
cin >> size;
int dynamicArray[size];

Ответ 10

static arrary meens с присвоением элементам в стороне массива

динамический аранжировщик без предоставления элементов в стороне массива

Пример:

     char a[10]; //static array
       char a[];  //dynamic array