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

В чем разница между статическим массивом и динамическим массивом в C ++?

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

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

Можете ли вы объяснить разницу между статическим массивом и динамическим массивом в 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[]значение, так что вы можете использовать его с той же семантикой , как массив.

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

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

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

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

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

Я думаю, в этом контексте это означает, что он статичен в том смысле, что размер фиксирован. Используйте 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