Динамические массивы в c: примеры, уроки программирования на С++

Динамический массив — это… Что такое Динамический массив?

Динамическим называется массив, размер которого может меняться во время исполнения программы. Для изменения размера динамического массива язык программирования, поддерживающий такие массивы, должен предоставлять встроенную функцию или оператор. Динамические массивы дают возможность более гибкой работы с данными, так как позволяют не прогнозировать хранимые объёмы данных, а регулировать размер массива в соответствии с реально необходимыми объёмами. В отличие от динамических массивов существуют статические массивы и массивы переменной длинны. Размер статического массива определяется на момент компиляции программы. Размер массива переменной длинны определяется во время выполнения программы. Отличием динамического массива от массива переменной длинны является автоматическое изменение размеров, что не трудно реализуется в случаях его отсутствия, поэтому часто не различают массивы переменной длины с динамическими массивами.

Пример динамического массива на языке «Pascal»

 byteArray : Array of Byte; // Одномерный массив
 multiArray : Array of Array of string;  // Многомерный массив

Динамические массивы (или массивы переменной длины) поддерживаются Delphi, FreePascal, но не Turbo Pascal.

Пример объявления динамического массива на языках C/C++

Одномерный динамический массив:

Создаем массив с 10-ю элементами типа int:

Си:

        int *mas = malloc (sizeof(int) * 10);

С++:

Получить доступ к значению каждого элемента можно по индексу (порядковый номер):

        mas[0] = 2; // присвоили значение 2 нулевому элементу массива mas
        mas[1] = 7; // присвоили значение 7 первому элементу массива mas
        //... и т.д.

Следовательно, если брать такой подход, то вам понадобится около десяти строк кода, чтобы проинициализировать весь массив. Для того, чтобы этого избежать напишем тоже самое в цикле:

       for(int i = 0; i < 10; i++){
               cin>>mas[i]; // пользователь вводит значение каждого i-того элемента массива
       }

После чего работаем с массивом. Также его можно вывести на экран:

       for(int i = 0; i < 10; i++){
               cout << mas[i] << endl;
       }

Для освобождения из памяти одномерного динамического массива используем:

Си:

С++: оператор delete:

Строго говоря вышеописанная реализация массива не является динамической, т.к. нет изменения размера массива во время работы, а всего лишь массивом переменной длины. Возможным решением является realloc, но можно применить только при использовании malloc, но не new. Для того чтобы изменить размер такого массива необходимо объявить еще один массив нужного размера, скопировать в него все данные и освободить память занимаемую старым массивом. В С++ библиотечным решением является std::vector. В С89 нет массивов переменной длины, они есть только в С99 (который поддерживают не все компиляторы). Некоторые (довольно старые) компиляторы С++ также не поддерживают массивов переменной длинны.

Ссылки

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

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

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

int x[10]; 
static int y[10]; 
foo() {
    static int z[10]; 

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

foo() {
    int w[10]; 

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

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

абсолютные адреса для доступа к массивам. что невозможно при хранении на основе стека.

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

foo() {
   int *d = new int[n]; 

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

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

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

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

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

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

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

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

Статический массив и динамический массив в C++

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

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

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

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

    int w[10]; //automatic array

То, что эти массивы , х, у, Z, и W имеют то общее, что размер для каждой из них является фиксированной и определяется во время компиляции.

Одна из причин того, что он’s важно понимать различие между автоматическим массива и статического массива заключается в том, что статическое хранение, как правило, реализуется в данные (или БСС раздел) объектного файла и компилятор может использовать absolute адреса для доступа к arrays

что невозможно при стековой памяти.

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

   int *d = new int[n]; //dynamically allocated array with size n     

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

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

Для истинного динамического массива нужно использовать что-то типа СТД::вектор в C++ (или переменную длину массива в C]8).

Что имеется в виду назначение в ОП’ы вопрос? Я думаю, что это’ы понятно, что то, что хотел, не был статический или автоматический массив, но никто что либо использовать динамическое выделение памяти с помощью оператора

new или нефиксированного размера массива, используя например, СТД::вектор.

2. Динамические массивы — Документация Programming

Массивы в языке C

Массив — это тип данных, состоящий из элементов, расположенных в памяти последовательно .

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

В стандарте С89 размер массива должен быть известен на этапе компиляции. В стандарте С99 появились массивы переменной длины (Variable-length array), но сохранялось ограничение: после объявления массива невозможно изменить количество элементов в нем.

Массив нельзя передать в функцию. Функции, работающие с массивами, принимают указатель на нулевой элемент и, как правило, размер массива, поскольку нет переносимого способа узнать размер массива, располагая только указателем на нулевой элемент.

Память для массивов выделяется в стеке . Память в стеке выделяется и освобождается автоматически, что значительно упрощает работу с ней. Однако размер стека ограничен. Его можно узнать, выполнив команду:

В приведенном примере размер стека составляет 8МБ. Для изменения размера стека требуются права администратора.

Динамические массивы

На практике часто возникают задачи, в которых размер массива неизвестен на этапе компиляции, а также может меняться в процессе работы приложения. При этом требуется сохранить преимущества обычных массивов: обращение к элементам за O(1). В таких случаях используют динамические массивы, которые по историческим причинам в контексте языка C++ называют векторами.

Вектор состоит из трех компонент:

1. Указатель на участок памяти, в котором хранятся элементы.
2. Размер. Количество заполненных элементов
3. Емкость. Количество элементов, для которых зарезервирована память.

Ниже изображен вектор емкостью 7, состоящий из 5 элементов: 3, 1, 4, 1, 5. | size = 5

Базовые операции с вектором.

IntVector *int_vector_new(size_t initial_capacity)

Создает массив нулевого размера.

Параметры:	initial_capacity (size_t) – исходная емкость массива
Результат:	указатель на IntVector, если удалось выделить память. Иначе NULL.

Implementation note: поскольку функция возвращает указатель, в реализации ожидается выделение двух участков памяти: для структуры IntVector и для массива внутри структуры. Функция должна корректно обрабатывать ошибку при выделении любого из участков памяти, не должна возвращать указатель частично сформированный объект и не должна приводить к утечкам памяти в случае ошибки.

IntVector *int_vector_copy(const IntVector *v)

Результат:	Указатель на копию вектора v. NULL, если не удалось выделить память.

void int_vector_free(IntVector *v)

Освобождает память, выделенную для вектора v.

int int_vector_get_item(const IntVector *v, size_t index)

Результат:	элемент под номером index. В случае выхода за границы массива поведение не определено.

void int_vector_set_item(IntVector *v, size_t index, int item)

Присваивает элементу под номером index значение item. В случае выхода за границы массива поведение не определено.

size_t int_vector_get_size(const IntVector *v)

Результат:	размер вектора.

size_t int_vector_get_capacity(const IntVector *v)

Результат:

емкость вектора. | size = 7 void int_vector_pop_back(IntVector *v) Удаляет последний элемент из массива. Нет эффекта, если размер массива равен 0. int int_vector_shrink_to_fit(IntVector *v) Уменьшает емкость массива до его размера. Результат: 0 в случае успешного изменения емкости, -1 в случае ошибки. int int_vector_resize(IntVector *v, size_t new_size) Изменяет размер массива. Если новый размер массива больше исходного, то добавленные элементы заполняются нулями. Если новый размер массива меньше исходного, то перевыделение памяти не происходит. Для уменьшения емкости массива в этом случае следует использовать функцию int_vector_shrink_to_fit. Результат: 0 в случае успеха, -1 в случае ошибки. Если не удалось изменить размер, массив остается в исходном состоянии. int int_vector_reserve(IntVector *v, size_t new_capacity) Изменить емкость массива. Нет эффекта, если новая емкость меньше либо равна исходной. Результат: 0 в случае успеха, -1 в случае ошибки. Если не удалось изменить емкость, массив остается в исходном состоянии. Динамические массивы в Excel Что такое динамические массивы В сентябре 2018 года Microsoft выпустила обновление, которое добавляет в Microsoft Excel совершенно новый инструменты: динамические массивы (Dynamic Arrays) и 7 новых функций для работы с ними. Эти вещи, без преувеличения, совершенно кардинальным образом меняет всю привычную технику работы с формулами и функциями и касаются, буквально, каждого пользователя. Рассмотрим простой пример, чтобы объяснить суть. Предположим, что у нас есть простая табличка с данными по городам-месяцам. Что будет если мы выделим любую пустую ячейку справа на листе и введем в нее формулу-ссылку не на одну ячейку, а сразу на диапазон? Во всех прошлых версиях Excel после нажатия на Enter мы бы получили содержимое только одной первой ячейки B2. А как иначе? Ну, или можно было бы завернуть этот диапазон в какую-нибудь аггрегирующую функцию типа =СУММ(B2:C4) и получить по нему общий итог. Если бы нам потребовались операции посложнее примитивной суммы, например, извлечение уникальных значений или Топ-3, то пришлось бы вводить нашу формулу как формулу массива, используя сочетание клавиш Ctrl+Shift+Enter. Теперь всё по-другому. Теперь после ввода такой формулы мы можем просто нажать на Enter — и получить в результате сразу все значения, на которые мы ссылались: Это не магия, а новые динамические массивы, которые теперь есть в Microsoft Excel. Добро пожаловать в новый мир :) Особенности работы с динамическими массивами Технически, весь наш динамический массив хранится в первой ячейке G4, заполняя своими данными необходимое количество ячеек вправо и вниз. Если выделить любую другую ячейку массива, то в строке формул ссылка будет неактивной, показывая, что мы находимся в одной из «дочерних» ячеек: Попытка удалить одну или несколько «дочерних» ячеек ни к чему не приведёт — Excel тут же заново их вычислит и заполнит. При этом ссылаться на эти «дочерние» ячейки в других формулах мы можем совершенно спокойно: Если копировать первую ячейку массива (например из G4 в F8), то и и весь массив (его ссылки) сдвинется в том же направлении, как и в обычных формулах: Если нам нужно переместить массив, то достаточно будет перенести (мышью или сочетанием Ctrl+X, Ctrl+V), опять же, только первую главную ячейку G4 — вслед за ней перенесется на новое место и заново развернётся весь наш массив. Если вам нужно сослаться где-нибудь еще на листе на созданный динамический массив, то можно использовать спецсимвол # («решётка») после адреса его ведущей ячейки: Например, теперь можно легко сделать выпадающий список в ячейке, который ссылается на созданный динамический массив: Ошибки динамических массивов Но что будет, если для развёртывания массива не будет достаточно пространства или на его пути окажутся ячейки уже занятые другими данными? Знакомьтесь с принципиально новым типом ошибок в Excel — #ПЕРЕНОС! (#SPILL!): Как всегда, если щелкнуть мышью по значку с желтым ромбом и восклицательным знаком, то мы получим более подробное пояснение по источнику проблемы и сможем быстро найти мешающие ячейки: Аналогичные ошибки будут возникать, если массив выходит за пределы листа или натыкается на объединенную ячейку. Если удалить препятствие, то всё тут же исправится на лету. Динамические массивы и «умные» таблицы Если динамический массив указывает на «умную» таблицу, созданную сочетанием клавиш Ctrl+T или с помощью Главная — Форматировать как таблицу (Home — Format as Table), то он также унаследует её главное качество — автоподстройку размеров. При добавлении новых данных внизу или справа «умная» таблица и динамический диапазон тоже будут автоматически растягиваться: При этом, однако, есть одно ограничение: мы не можем использовать ссылку на динамический диапазон в форумулах внутри «умной» таблицы: Динамические массивы и другие функции Excel Хорошо, скажете вы. Всё это интересно и забавно. Не нужно, как раньше, вручную протягивать формулу со ссылкой на первую ячейку исходного диапазона вниз и вправо и всё такое. И всё? Не совсем. Динамические массивы — это не просто еще один инструмент в Excel. Теперь они внедрены в самое сердце (или мозг) Microsoft Excel — его вычислительный движок. А это значит что и другие, привычные нам формулы и функции Excel теперь тоже поддерживают работу с динамическими массивами. Давайте разберём несколько примеров, чтобы вы осознали всю глубину произошедших изменений. Транспонирование Чтобы транспонировать диапазон (обменять местами строки и столбцы) в Microsoft Excel всегда имелась встроенная функция ТРАНСП (TRANSPOSE). Однако, чтобы её использовать, вы должны были сначала правильно выделить диапазон для результатов (например, если на входе был диапазон 5х3, то вы должны были обязательно выделить 3×5), потом ввести функцию и нажать сочетание Ctrl+Shift+Enter, т.к. она умела работать только в режиме формул массива. Теперь можно просто выделить одну ячейку, ввести в нее эту же формулу и нажать на обычный Enter — динамический массив сделает всё сам: Таблица умножения Этот пример я обычно приводил, когда меня просили наглядно показать преимущества формул массива в Excel. Теперь чтобы посчитать всю таблицу Пифагора достаточно встать в первую ячейку B2, ввести туда формулу перемножающую два массива (вертикальный и горизонтальный набор чисел 1..10) и просто нажать на Enter: Склейка и преобразование регистра Массивы можно не только перемножать, но склеивать стандартным оператором & (амперсанд). Предположим, нам нужно сцпеить имя и фамилию из двух столбцов и поправить скачущий регистр в исходных данных. Делаем это одной короткой формулой, которая формирует весь массив, а потом применяем к нему функцию ПРОПНАЧ (PROPER), чтобы привести в порядок регистр: Вывод Топ-3 Предположим, что у нас есть куча чисел, из которых нужно вывести три лучших результата, расположив их в порядке убывания. Теперь это делается одной формулой и, опять же, без всяких Ctrl+Shift+Enter как раньше: Если захочется, чтобы результаты располагались не в столбец, а в строку, то достаточно заменить в этой формуле двоеточия (разделитель строк) на точку с запятой (разделитель элементов внутри одной строки). В англоязычной версии Excel роль этих разделителей играют точка с запятой и запятая, соответственно. ВПР извлекающая сразу несколько столбцов Функцей ВПР (VLOOKUP) теперь можно вытаскивать значения не из одного, а сразу из нескольких столбцов — достаточно указать их номера (в любом желаемом порядке) в виде массива в третьем аргументе функции: Функция СМЕЩ (OFFSET) возвращающая динамический массив Одной из самых интересных и полезных (после ВПР) функций для анализа данных является функция СМЕЩ (OFFSET), которой я посвятил в своё время целую главу в своей книжке и статью здесь. Сложность в понимании и освоении этой функции всегда была в том, что она возвращала в качестве результата массив (диапазон) данных, но увидеть его мы не могли, т.к. Excel до сих пор не умел работать с массивами «из коробки». Сейчас эта проблема в прошлом. Посмотрите, как теперь с помощью одной формулы и динамического массива, возвращаемого СМЕЩ, можно извлечь все строки по заданному товару из любой отсортированной таблицы: Давайте разберём её аргументы: А1 — стартовая ячейка (точка отсчёта) ПОИСКПОЗ(F2;A2:A30;0) — вычисление сдвига от стартовой ячейки вниз — до первой найденной капусты. 0 — сдвиг «окна» вправо относительно стартовой ячейки СЧЁТЕСЛИ(A2:A30;F2) — вычисление высоты возвращаемого «окна» — количества строк, где есть капуста. 4 — размер «окна» по горизонтали, т.е. выводим 4 столбца Новые функции для динамических массивов Помимо поддержки механизма динамических массивов в старых функциях, в Microsoft Excel были добавлены несколько совершенно новых функций, заточенных именно под работу с динамическими массивами. В частности, это: СОРТ (SORT) — сортирует входной диапазон и выдает динамический массив на выходе СОРТПО (SORTBY) — умеет сортировать один диапазон по значениям из другого ФИЛЬТР (FILTER) — извлекает из исходного диапазона строки, удовлетворяющие заданным условиям УНИК (UNIQUE) — извлекает из диапазона уникальные значения или убирает повторы СЛМАССИВ (RANDARRAY) — генерит массив случайных чисел заданного размера ПОСЛЕД (SEQUENCE) — формирует массив из последовательности чисел с заданным шагом Подробнее про них — чуть позже. Они стоят отдельной статьи (и не одной) для вдумчивого изучения 🙂 Выводы Если вы прочитали всё написанное выше, то, думаю, уже осознаёте масштаб изменений, которые произошли. Очень многие вещи в Excel теперь можно будет делать проще, легче и логичнее. Я, признаться, немного в шоке от того, сколько статей теперь придется корректировать здесь, на этом сайте и в моих книгах, но готов это сделать с легким сердцем. Подбивая итоги, в плюсы динамических массивов можно записать следующее: Можно забыть про сочетание Ctrl+Shift+Enter. Теперь Excel не видит различий между «обычными формулами» и «формулами массива» и обрабатывает их одинаково. Про функцию СУММПРОИЗВ (SUMPRODUCT), которую раньше использовали для ввода формул массива без Ctrl+Shift+Enter тоже можно забыть — теперь достаточно просто СУММ и Enter. Умные таблицы и привычные функции (СУММ, ЕСЛИ, ВПР, СУММЕСЛИМН и т.д.) теперь тоже полностью или частично поддерживают динамические массивы. Есть обратная совместимость: если открыть книгу с динамическими массивами в старой версии Excel, то они превратятся в формулы массива (в фигурных скобках) и продолжат работать в «старом стиле». Нашлось и некоторое количество минусов: Нельзя удалить отдельные строки, столбцы или ячейки из динамического массива, т.е. он живёт как единый объект. Нельзя сортировать динамический массив привычным образом через Данные — Сортировка (Data — Sort). Для этого есть теперь специальная функция СОРТ (SORT). Динамический диапазон нельзя превратить в умную таблицу (но можно сделать динамический диапазона на основе умной таблицы). Само-собой, это еще не конец и, я уверен, Microsoft продолжит совершенствовать этот механизм в будущем. Где скачать? И, наконец, главный вопрос :) Microsoft впервые анонсировало и показало превью динамических массивов в Excel еще в сентябре 2018 года на конференции Ignite. В последующие несколько месяцев происходило тщательное тестирование и обкатка новых возможностей сначала на кошках сотрудниках самой Microsoft, а потом на добровольцах-тестировщиках из круга Office Insiders. В этом году обновление, добавляющее динамические массивы стали постепенно раскатывать уже по обычным подписчикам Office 365. Я, например, получил его только в августе с моей подпиской Office 365 Pro Plus (Monthly Targeted). Если в вашем Excel ещё нет динамических массивов, а поработать с ними очень хочется, то есть следующие варианты: Если у вас подписка Office 365, то можно просто продождать, пока до вас дойдет это обновление. Как быстро это случится — зависит от настройки частоты доставки обновлений для вашего Office (раз в год, раз в полгода, раз в месяц). Если у вас корпоративный ПК, то можно попросить вашего администратора настроить загрузку обновлений почаще. Можно записаться в ряды тех самых добровольцев-тестировщиков Office Insiders — тогда вы будете первым получать все новые возможности и функции (но есть шанс повышенной глючности в работе Excel, само-собой). Если у вас не подписка, а коробочная standalone-версия Excel, то придется ждать до выхода следующей версии Office и Excel в 2022 году, как минимум. Пользователи таких версий получают только обновления безопасности и исправления ошибок, а все новые «плюшки» теперь достаются только подписчикам Office 365. Sad but true 🙂 В любом случае, когда динамические массивы появятся в вашем Excel — после этой статьи вы будете к этому уже готовы 🙂 Ссылки по теме C++, Динамические массивы, Нулевая матрица 🙂 — Pyatnitsev Home Хочется вспомнить былое, так что решил поднять старые задачки и решить их снова, и по-новому. Матрица называется нулевой, если все ее элементы равны нулю. Напишите программу, которая принимает с клавиатуры число N, создает нулевую матрицу размера N на N и выводит ее на экран. Исходник решил написать, используя динамический массив и си++ стиль. Комментариев по коду достаточно. Теория по динамическим массивам в си++ #include <iostream> using namespace std; int main() { int n = 0; cin >> n; // Считываем с клавиатуры n int **a = new int* [n]; // Создаем массив указателей for (int i = 0; i < n; i++) { a[i] = new int [n]; // Создаем элементы } // А дальше работа как с обычным массивом. for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { a[i][j] = 0; // Каждый элемент равен нулю cout << a[i][j] << » «; // Вывести элементы на консольку } cout << endl; // Двумерный массив. Строка кончилась, переводим строку и на консоли } // Удаление массива for (int i = 0; i < n; i++) { delete[]a[i]; // Удаляем каждый элемент } delete [] a; // А потом массив return 0; } 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 #include <iostream>   using namespace std;   int main() { int n = 0; cin >> n; // Считываем с клавиатуры n int **a = new int* [n]; // Создаем массив указателей for (int i = 0; i < n; i++) { a[i] = new int [n]; // Создаем элементы } // А дальше работа как с обычным массивом. for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { a[i][j] = 0; // Каждый элемент равен нулю cout << a[i][j] << » «; // Вывести элементы на консольку } cout << endl; // Двумерный массив. Строка кончилась, переводим строку и на консоли } // Удаление массива for (int i = 0; i < n; i++) { delete[]a[i]; // Удаляем каждый элемент } delete [] a; // А потом массив return 0; } Пример работы: стеков с использованием динамических массивов в c Совет: используйте два стека, один для хранения всех элементов, а второй для хранения максимумов. Программа на C успешно скомпилирована и запускается (на кодовых блоках) в системе Windows. Здравствуйте, друзья, я свободный преподаватель Лэнс, который помог студенту выполнить домашнее задание. # 2) Использование связного списка. Использует оптимизированный своп XOR для замены элементов. связанный список. Он включает в себя различные операции, такие как push, pop, stack empty, stack full и display. Последовательность выхода.Распределение динамической памяти в стеке C ++. Жадный алгоритм, динамическое программирование, график, попытки, массивы, рекурсия, связанные списки, деревья, HashMap, стеки, очереди, кучи Что вы узнаете Изучите сильные и слабые стороны различных структур данных, чтобы вы могли выбрать лучшие данные структура для ваших данных и приложений Библиотека двусторонних очередей DEQlib. Это меня некоторое время беспокоило, но я понял это. Группа вариантов ответа True / False. Другими словами, распределение динамической памяти относится к выполнению управления памятью для распределения динамической памяти вручную.Недостаток стека, реализованного с использованием массива, заключается в том, что его размер фиксирован и должен быть указан во время компиляции. Начальный размер массива и коэффициент его роста определяют его производительность. Вам необходимо выполнить два метода — push () и pop (). Это называется распределением динамической памяти. Push — это добавляет значение данных в верхнюю часть стека. — стек: локальное хранилище переменных… Выход. Библиотека хранения динамических массивов DASlib. Все операции со стеком выполняются с использованием массивов. В этой статье мы узнаем, как реализовать динамический стек с использованием массива.В реализации массива стек формируется с использованием массива. Все операции со стеком выполняются с использованием массивов. Во-первых, давайте рассмотрим, как мы реализовали простой стек на основе массива в нашей предыдущей статье «Реализация стека с использованием массива в Java». Параметры передаются через эту функцию и их адреса возврата. Правило оценки постфиксного выражения гласит: читая выражение слева направо, вставьте элемент в стек, если это операнд. Вопрос на собеседовании.Создание массива структур с помощью функции malloc () на языке C. Есть еще один способ создать массив структур на языке C. Память может быть выделена с помощью функции malloc () для массива структур. Стек используется для временной передачи данных между вызовами функций, куча — это более «глобальное» пространство для хранения объектов. Динамический массив (вектор в C ++, ArrayList в Java) автоматически увеличивается, когда мы пытаемся сделать вставку, и для нового элемента больше не остается места. Обычно размер области увеличивается вдвое.Когда функция объявляет переменную, эта переменная помещается в стек. Принцип стека LIFO. В этой статье мы будем кодировать стек и все его функции, используя массив. Следующее, что нужно сделать для создания стека, — это создание указателя «сверху». Стеки могут быть реализованы с использованием массивов линейного типа. PostScript — это стековый язык, используемый большинством принтеров. С помощью функции free () освободим занятую память. Я начал изучать массивы на C ++ и наткнулся на небольшую заметку в книге, в которой говорилось о 2D-массивах вкратце.Предыдущая: Стеки в C; Создание стека с использованием связанного списка на C; Предыдущая статья была полностью посвящена концепции стека. Добавление нового стека элементов и удаление существующих элементов производится с одной стороны, это называется вершиной стека. Я также направляю их в работу над проектами последнего года. Он поставляется со стандартными библиотеками на многих современных основных языках программирования. В этом руководстве вы научитесь работать с массивами. Реализация стека с использованием динамического массива в C ++ Определение API.2) Программа C для ввода и печати текста с использованием динамического распределения памяти. char * pvalue = NULL; // Указатель инициализируется нулевым значением pvalue = new char [20]; // Запрашиваем память для переменной. Если вы новичок в структуре данных стека, прочтите наши статьи о стеке на Stack… Чтобы узнать больше, в том числе о том, как управлять файлами cookie, см. Здесь: Политика использования файлов cookie.% D блоггерам нравится это: Стек — это линейная структура данных, в которую вставляются и удаляются элементов занимает только один конец, известный как TOP. Вы можете попробовать программу, нажав на кнопку «Попробовать».• В стеке удаленный элемент является последним вставленным элементом. STACK использует в своих операциях подход «последний пришел — первым обслужен». Массивы в C. Массив — это переменная, которая может хранить несколько значений. Используйте C ++, чтобы ответить на этот вопрос. ДИНАМИЧЕСКИЙ Массив C ++ В C ++ нет встроенного динамического массива, хотя в стандартной библиотеке шаблонов есть шаблон под названием vector, который делает то же самое. Мы ограничены использованием только … Функция PUSH в коде используется для вставки элемента в верхнюю часть стека, функция POP используется для удаления элемента из верхней части стека.Вставьте элемент. Проблема Решение 1. 8. Для хранения всего списка мы используем 2-мерный массив строк на языке Си. Если стек заполнен, это называется условием переполнения. Стек следует структуре данных «первым пришел последний ушел» (FILO). Отправлено IncludeHelp 25 августа 2016 г. Используйте оператор switch для доступа к этим функциям. Точно так же, когда элементы удаляются из стека, он сжимается с того же конца. Динамическая память выделяется с помощью оператора new. Создайте специальный динамический стек, используя массив, который поддерживает все операции со стеком, такие как push (), pop (), peek (), isEmpty () и getMin () с постоянной сложностью времени и пространства.. Стек на основе растущего массива может быть реализован путем выделения новой памяти большего размера, чем память предыдущего стека, и копирования элементов из старого стека в новый стек. Реализация на языке C Описание проблемы Эта программа реализует операции со стеком с использованием динамического распределения памяти. Если программа потребляет больше места в памяти, произойдет переполнение стека, поскольку размер стека ограничен в памяти компьютера. peek () — получить верхний элемент данных стека, не удаляя его. Традиционные массивы в стиле C являются источником многих ошибок, но все еще распространены, особенно в старых базах кода.В абстрактном типе данных (или ADT) есть набор правил или описание операций, которые разрешены с данными. Удобный для кеширования. Назначение динамической структуры данных типа «стек». Его синтаксис: указатель = новый тип. Массив — это статическая структура данных, поэтому размер сбора данных должен быть фиксированным. При таком подходе перемещение n элементов занимает время, пропорциональное n (не n2). Стек — это абстрактный тип данных, который демонстрирует поведение Last in first out (LIFO). Мы реализуем то же поведение с помощью Array.например Я не уверен, как объявить массив в файле .h. A После этого модифицируется стек. Это называется динамическим распределением памяти в программировании на C. Остальная часть области динамической памяти обычно выделяется в куче, из которой прикладные программы могут при необходимости динамически выделять память. C имеет три разных пула памяти. Файл кода стека: stack.c (реализация стека на C) Мы можем протестировать структуру данных стека, которая использует массив в файле main.c (программа стека на C). Ниже приводится вывод программы: Теперь давайте реализуем стек используя динамический массив, то есть, если массив заполнен, создайте новый массив вдвое большего размера и скопируйте элементы.В компьютере есть два специальных регистра: указатель стека и указатель кадра. Он содержит хорошо написанные, хорошо продуманные и хорошо объясненные статьи по информатике и программированию, викторины и вопросы по практике / соревновательному программированию / собеседованию с компанией. Разработайте структуру данных очереди (FIFO) с помощью динамического массива. Динамические массивы также можно создавать и удалять с помощью команд new и delete (таким образом, используя кучу, а не стек). 2. Он использует стандартные функции выделения памяти malloc / realloc и простую стратегию изменения размера «удвоения размера».Как и массивы, динамические массивы размещают элементы в памяти рядом друг с другом, обеспечивая эффективное использование… Самый низкий адрес соответствует первому элементу, а самый высокий адрес — последнему элементу. Объявите 2D-массив для доступа к элементам с нотацией arr [x] [y]. Когда вы объявляете переменную с использованием базового типа данных, компилятор C автоматически выделяет пространство памяти для переменной в пуле памяти, называемом стеком. Например, переменная типа float обычно занимает 4 байта (в зависимости от платформы), когда она заявил.В этом посте мы узнаем о реализации стека с использованием массива на языке C. Вот исходный код программы C для реализации операций над стеком с использованием массивов. В этом посте вы узнаете, как массивы и список понравившихся используются для представления стека. В классе не менее четырех членов: указатель на экземпляр Type, Type * array, который будет использоваться в качестве массива, счетчик int count, Static имеет несколько различных значений: * Статический член класса — это тот, который доступен в момент запуска исполняемого файла и остается доступным в течение всего выполнения.Динамические массивы имеют переменный размер и поэтому более гибкие. Костный и суставной открытый импакт-фактор, Результаты румынского футбола, Как предотвратить появление водорослей в аквариуме, Список частных бассейнов в Булакане, Толстовка с капюшоном Flannel Combo Womens, Богемское пиво Саскачеван, Цветовая палитра темного шоколада, Периоды после прекращения приема прогестерона, Доля рынка селена, Джастин Верландер Травма 2021, Книжный магазин Академия Святого Креста, Белое джинсовое платье Fashion Nova, Что такое динамические массивы в C Массив — это мощная и простая в использовании структура данных, представленная на языке C.Мы знаем, что массивы обеспечивают легкий доступ к своим элементам, а целые массивы можно легко манипулировать с помощью циклов. Однако есть некоторые недостатки / ограничения массивов: 1. Невозможность изменить размер массива во время выполнения: Поскольку память для массивов выделяется во время компиляции, невозможно изменить размер массива во время выполнения программы. . Таким образом, если заявленный размер массива в какой-то ситуации недостаточен, исполняемая программа практически бесполезна. В таких ситуациях нам необходимо соответствующим образом изменить исходный код и перекомпилировать программу.Это либо невозможно (если исходный код недоступен), либо очень сложно (если исполняемый файл должен быть распространен среди большого количества людей). Кроме того, невозможно уменьшить размер массива для экономии памяти в ситуациях, когда требуется меньшее количество элементов массива. 2. Неустойчивое использование памяти: Поскольку размер массива не может быть увеличен во время выполнения, программист имеет тенденцию объявлять массивы намного больше, чем обычно требуется, для обслуживания некоторых непредвиденных ситуаций. Это приводит к потере памяти при большинстве казней. Чтобы преодолеть эти ограничения, мы можем реализовать динамические массивы , используя функцию динамического распределения памяти языка C. Это позволяет программисту выделять для массивов только необходимую память. Например, если в классе всего 35 студентов, массив для хранения имен студентов этого класса будет выделен для хранения только 35 элементов. С другой стороны, при использовании статического распределения памяти мы могли бы использовать гораздо большие массивы, скажем, имеющие 100 элементов, что приведет к большой потере памяти. Общие шаги для работы с динамическим массивом типа Tare следующие: 1. Переменная-указатель подходящего типа (скажем, T * для вектора, T ** для матрицы и т. Д.) Объявляется, чтобы указать на массив, память для которого должна быть выделена во время выполнения. 2. Во время выполнения программы определяется желаемый размер массива (например, посредством взаимодействия с пользователем, файлового ввода-вывода или с помощью некоторых вычислений). 3. Требуемая память динамически выделяется указателю, предпочтительно с использованием определяемой пользователем функции выделения памяти (например,g., ivec_alloc для вектора int, imat_alloc для матрицы int и т. д.), который, в свою очередь, использует функции malloc или calloc. 4. Теперь динамический массив можно использовать обычным образом. Таким образом, к его элементам можно получить доступ с помощью операторов индекса (например, a [ i ] для вектора, a [ i ] [j] для матрицы и т. Д.), А массив можно обработать с помощью циклов. Кроме того, мы можем передавать эти массивы функциям, хотя есть некоторые различия для двух и более высоких измерений. 5.При желании мы можем изменить размер этого массива, предпочтительно с помощью пользовательской функции (скажем, ivec_realloc, imat_realloc и т. Д.), Которая, в свою очередь, использует стандартную библиотечную функцию realloc и продолжает работать с ней. 6. Когда этот динамический массив больше не требуется в программе, мы должны вернуть его в систему, используя бесплатную функцию для векторов и определяемую пользователем функцию (например, imat _free) для матриц и многомерных массивов. Как мы только что видели, для динамического выделения массива требуется довольно много кода.Если программе требуется большое количество динамических массивов, что вполне возможно даже в небольшом приложении, мы получим много повторяющегося кода для распределения памяти. Мы можем избежать этого повторяющегося кода и сделать наши программы краткими и более удобочитаемыми, определив функции для выделения / освобождения таких массивов. Язык C Два способа создания динамических массивов Есть два способа создать динамический массив. Потому что этот талант неглубокий, знания неглубокие, есть неподходящие места, чтобы правильно смотреть, спасибо! Объявите указатель, вызовите malloc (), назначьте его возвращаемое значение указателю и используйте указатель для доступа к элементам массива.И этот указатель может быть статическим или автоматическим Объявите массив переменной длины (VLA), новую функцию c99. Используйте выражение переменной для представления размеров массива. Эти два метода функционально схожи. Например, оба могут определять размер массива во время выполнения: int a () { int n; int * pi; scanf ("% d", & n); pi = (int *) malloc (n * sizeof (int)); int ar [n]; пи [2] = ар [2] = -5; ... } Разница между массивом переменной длины (VLA) и malloc (): Массивы переменной длины являются автоматическими типами хранения, поэтому программа выполняет функцию a (), и пространство памяти, занимаемое массивом переменной длины, автоматически освобождается. Массив, созданный malloc (), не ограничивается доступом к функции. Например: вызываемая функция создает массив и возвращает указатель для доступа вызывающей функции, затем вызывающая функция вызывает функцию free () в конце, чтобы освободить память, выделенную вызываемой функцией. В случае многомерных массивов удобнее использовать массивы переменной длины. Создание двумерного массива с помощью malloc () утомительно. Если компилятор не поддерживает функцию массива переменной длины (не поддерживается в VC ++ 6.0) можно только зафиксировать размеры двумерного массива. выглядит следующим образом: int n = 5; int m = 6; int ar [n] [m]; int (* p1) [6]; int (* p2) [м]; p1 = (int (*) [6]) malloc (n * 6 * sizeof (int)); p2 = (int (*) [m]) malloc (n * m * sizeof (int)); ар [1] [2] = p1 [1] [2] = 1; Каковы преимущества использования динамических массивов? Использование динамических массивов придает программе большую гибкость. Если вы уже знаете, в большинстве программ используется не более 100 элементов, но иногда требуется 100 000 элементов.Если вы будете следовать обычному порядку, вы должны объявить элемент 100000 для этой ситуации. По сути, это пустая трата памяти. Если вам нужен 10002, эту программу использовать нельзя. В этом случае вы можете использовать программу настройки динамического массива для различных ситуаций. О функции malloc (): malloc () массивов C ++ массивов C ++ Массивы C ++ Массивы C ++ несколько отличаются от массивов Java. Есть массивы объявляются статически, а массивы объявляются динамически.Все массивы ссылки. Значение массива — это его адрес. Как и в Java, индексы массивов начинаются с нуля. В C ++ массивы не умеют у них много элементов. Статически объявленные массивы Статически объявленные массивы выделяют память во время компиляции и их размер фиксированный, т.е. не может быть изменен позже. Их можно инициализировать аналогично Java. Например, объявлено два массива int, один инициализирован, а другой нет. int a [10]; int b [5] {8, 20, 25, 9, 14}; Массив & nbsp a & nbsp состоит из 10 элементов с пронумерованными индексами. от 0 до 9, залил мусор.Массив & nbsp b & nbsp состоит из 5 элементов с пронумерованными индексами. от 0 до 4, заполненных пятью заданными значениями. Доступ к ним осуществляется обычным способом, например, a [5] или b [2]. Память выделяется во время компиляции. Образ памяти этих массивов показать 10 значений мусора int и 5 допустимых значений int: __ ___ ___ ___ ___ ___ ___ ___ ___ ___ ___ а | - | -> | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | - --- --- --- --- --- --- --- --- --- --- 0 1 2 3 4 5 6 7 8 9 __ ___ ___ ___ ___ ___ б | - | -> | 8 | 20 | 25 | 9 | 14 | - --- --- --- --- --- --- Статические многомерные массивы объявляются с несколькими измерениями.Например, двумерный массив a имеет 3 строки и 4 столбца: int a [3] [4]; Картинка в памяти, которая поможет вам решить проблемы, — это показано ниже. На самом деле память непрерывна, поэтому эта двумерная массив действительно хранится как один длинный одномерный массив. это хранится в так называемом порядке строк, то есть по строкам. В памяти, второй ряд следует за первым рядом, а третий ряд следует за второй ряд. __ ___ ___ ___ ___ а | - | -> 0 |... | ... | ... | ... | - --- --- --- --- 1 | ... | ... | ... | ... | --- --- --- --- 2 | ... | ... | ... | ... | --- --- --- --- 0 1 2 3 Динамически объявленные массивы Если вы хотите иметь возможность изменять размер вашего массива во время выполнения, затем объявите динамические массивы. Это делается с помощью указателей и новый оператор. Основные сведения об указателях см. В раздел указателей. Выделите память с помощью new, а затем вы получите доступ к массиву в так же, как и статический массив.Например, int * arrayPtr = новый int [10]; для (int i = 0; i Картина памяти идентична статическому массиву, но вы можете при необходимости измените размер. Не забывай, ты должен освободить память перед выделением новой памяти (или у вас будет утечка памяти). удалить [] arrayPtr; // [] необходим при удалении указателей на массивы arrayPtr = новый интервал [50]; . . . Когда вы полностью закончите работу с массивом, вы должны удалить его память: удалить [] arrayPtr; Динамические многомерные массивы выполняются аналогично Java.У вас будут указатели на указатели. Для примера см. динамических массивов динамических массивов Структуры данных и алгоритмы с шаблонами объектно-ориентированного проектирования на C ++ Вероятно, наиболее распространенный способ агрегирования данных — использовать массив. Хотя язык программирования C ++ действительно предоставляет встроенные поддержка массивов, эта поддержка не лишена недостатков. Массивы в C ++ не являются первоклассными типами данных. Не существует такой вещи, как выражение с массивом значений.Следовательно, вы не можете использовать массив в качестве параметра фактического значения функции; вы не можете вернуть значение массива из функции; вы не можете присвоить один массив другому. (Конечно, вы можете делать все эти вещи с указателем на массив). Кроме того, индексы массива варьируются от нуля до N -1, где N — размер массива, и нет проверки границ выражений индекса массива. И, наконец, размер массива статичен и фиксируется во время компиляции, если динамическое распределение памяти не используется явно программистом. Некоторые из этих характеристик массивов отчасти связаны с тем, что в C ++ учитывая указатель T * ptr на некоторый тип T, невозможно сказать, просто по самому указателю, указывает ли он на единственный экземпляр переменной типа T или массиву переменных типа T. Более того, даже если мы знаем, что указатель указывает на массив, мы не можем определить фактическое количество элементов в этом массиве. Это в первую очередь устранение этих недостатков. что мы представляем объект Array который реализован как универсальный класс.На рисунке показан объект Array. представлен в памяти компьютера. Используются две конструкции. Первый — это структура, состоящая из трех полей — данных, базы и длины. Данные переменной-члена — это указатель на данные массива. База и длина переменных используются при расчете индекса массива. Вторая структура состоит из непрерывных ячеек памяти. которые содержат элементы массива. В реализации, представленной ниже, эта вторая структура размещается динамически. Рисунок: Представление объектов массива в памяти Объявление C ++ шаблона класса Array приведено в Program.Класс Array имеет три защищенные переменные-члены, данные, база и длина, конструкторы, деструктор и различные функции-члены. Количество функций-членов сведено к минимуму в этот пример — в « реальном мире » вы можете ожидать, что такой класс будет содержать еще много полезных функций-членов. На основе Программы, Теперь мы можем рассчитать общий объем необходимого хранилища для представления объектов Array. Пусть S ( n ) будет общим объемом памяти (памяти), необходимой для представляют объект Array который включает n элементов массива типа T. S ( n ) определяется где функция — это количество байтов используется для представления памяти экземпляра объекта типа X. В C ++ размеры основных (встроенных) типов данных являются фиксированными константами. То же самое и с размерами всех указателей. Следовательно, и. Следовательно, К сожалению, поскольку Array является универсальным классом, у нас нет априори знания объема памяти используется объектом типа T.Однако, если мы предположим, что объем памяти, используемый объектом типа T — фиксированная константа, тогда S ( n ) = O ( n ). Программа: Массив Определение класса Авторские права © 1997 Бруно Р. Прейсс, P.Eng. Все права защищены. динамический массив | Блестящая вики по математике и науке Динамический массив вносит важные накладные расходы как во времени, так и в пространстве. Время Если динамический массив перемещается так, что весь массив является непрерывным (и поэтому поиск выполняется за постоянное время), для увеличения и перемещения массива все равно потребуется время. В худшем случае асимптотически вставка нового элемента занимает O (n) O (n) O (n). Однако важно взглянуть на амортизированный анализ, чтобы увидеть, что время выполнения на самом деле меньше; в частности, O (1) O (1) O (1). Получить — O (1), Установить — O (1), Добавить * / Удалить в конце — O (1), Добавить / Удалить в начале — O (n), \ begin {array} {c} && \ text { Получить — O (1),} & \ text {Установить — O (1),} \\ & \ text {Добавить * / Удалить в конце — O (1),} & \ text {Добавить / Удалить в начале — O (n),} \ end {array} Добавить * / Удалить в конце — O (1) , Получить — O (1), Добавить / удалить в начале — O (n), Установить — O (1), * амортизированный анализ Площадь Как мы видели ранее, в динамическом массиве может быть избыточное пространство.Это избыточное пространство может быть определено как емкость-логический размер-емкость-логический размер-емкость-логический размер. В наихудшем случае это 2n − n + 12n — n + 12n − n + 1. Этот худший случай происходит сразу после роста динамического массива. Таким образом, пространство, используемое динамическим массивом, составляет O (2n) O (2n) O (2n), для фактора потраченного впустую пространства O (n) O (n) O (n). Это упрощает линейное пространство в большой нотации, но это важный фактор, о котором следует помнить при программировании. Пробел — O (n) \ begin {array} {c} && \ text {Пробел — O (n)} \ end {array} Пробел — O (n) Вы можете подумать, что программист может просто создать массив чрезвычайно большого размера, чтобы обойти накладные расходы на динамический массив.Но создание массива, который намного больше, чем вам нужно, чрезвычайно расточает память компьютера. Будет огромное количество неиспользуемого физического дискового пространства на время выполнения вашей программы. Программисту важно понимать свою программу и то, вызывает ли она массив или динамический массив. Урок 5 — Динамические массивы (векторы) на языке C На предыдущем уроке, Динамические строки и структуры на языке C, мы научились работать с динамически выделенные строки и структуры.До сих пор выделенная нам память была ограничено. Независимо от того, выделяли ли мы память динамически во время выполнения, или C выделил это для нас, мы всегда сталкивались с его пределами. Например, мы должны были следить от количества хранимых чисел, чтобы он не превышал размер массива. В следующих двух C учебники, мы наконец узнаем, как хранить неограниченное количество элементов в объем памяти. Мы дополним знания, необходимые для создания реальных приложений. в C. Динамические массивы (векторы) Мы уже знаем, что элементы массива хранятся сразу после друг друга в памяти.Мы также знаем, что размер массива ограничен. Как только мы создадим массив, мы должны указать, сколько места должно быть зарезервировано операционной системой (какой длины должен быть ряд нулей и единиц). Например, если мы запрограммировали телефонная книга, очень сложно оценить, сколько номеров будет у нашего пользователя. Будет 10 или 1000? Мы могли создать массив из 1000 телефонных номеров. Пользователь тогда использовали бы только его часть, и это все равно было бы лучшим решением, чем если бы мы недооценил размер массива, и приложение сообщило пользователю, что нет больше места для хранения (в лучшем случае) или если память переполнена.Но как сделать это правильно? … Конец превью … Продолжить дальше Вы получите знания на сотни тысяч за несколько крон Вы пришли сюда, и это здорово! Мы считаем, что первые уроки показали вам что-то новое и полезное. Хотите продолжить курс? Перейдите в премиум-раздел . Эта статья находится под лицензией: Premium, покупая эту статью, вы соглашаетесь с условиями использования. Автор — программист, увлекающийся веб-технологиями, ведущий автор статей на ICT. Оставить комментарий Добавить комментарий Отменить ответ Ваш адрес email не будет опубликован. Обязательные поля помечены * Комментарий * Имя * Email * Сайт