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

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

int foo[10];

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

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

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

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

Первый специфичен для C ++:

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

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

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

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

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

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

int x[10];

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

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

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

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

Статические переменные - это переменные, определенные с помощью статическое распределение памяти. Это общая концепция, не зависящая от C / C ++. В 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 / C ++ следующим образом:

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

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

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

Под динамическим массивом обычно подразумевается не тот, размер которого можно изменять, а тот, который реализован с использованием динамическое выделение памяти с фиксированным размером, определяемым во время выполнения. В C ++ это делается с помощью оператора 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 ++ (или массив переменной длины в C ).

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

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

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

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

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

Статический массив:

1. Статическим массивам выделяется память во время компиляции.
2. Размер фиксированный.
3. Находится в стековой памяти.
4. Например. : int array [10]; // массив размером 10

Динамический массив:

1. Память выделяется во время выполнения.
2. Размер не фиксирован.
3. Находится в области памяти кучи.
4. Например. : int * array = new int [10];

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

Статический массив: Эффективность. Никакого динамического выделения или освобождения не требуется.

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

статические произвольные меры с подачей элементов в сторону массива

динамический произвольный вид без дополнительных элементов в массиве

пример:

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