Как удалить динамический массив c

Как удалить динамический массив, возвращаемый функцией?

Она не принимает массив, но возвращает массив, созданный new. Как я понимаю, после возвращения массива, я теряю доступ к блоку памяти с массивом Array и не могу его удалить. Может быть понадобится функция удаления:

void delArray(unsigned short** Array, unsigned short raw) < for (unsigned short index = 0; index < raw; ++index) < delete[] Array[index]; >delete[] Array; > 

Функция в main:

#include #define Raw 12 #define Col 13 unsigned short** addArray(unsigned short raw, unsigned short col); void delArray(unsigned short** Array, unsigned short raw); int main(int argc, char* argv[]) < unsigned short** Arr = addArray(Raw, Col); delArray(Arr, Raw); _getch(); >unsigned short** addArray(unsigned short raw, unsigned short col) < unsigned short** Array = new unsigned short* [raw]; for (unsigned short index = 0; index < raw; ++index) < Array[index] = new unsigned short [col]; >return Array; > void delArray(unsigned short** Array, unsigned short raw) < for (unsigned short index = 0; index < raw; ++index) < delete[] Array[index]; >delete[] Array; > 

Было бы интересно узнать другие пути решения без заполнения памяти! Спасибо

C++ Динамический массив. Удаление элемента

P.S.
То, что ты написал — это не С++, а просто С.

#3
16:05, 28 янв 2008

Почему нет? Можно удалить элемент, потом вручную сдвинуть все элементы с удаленной позиции на единицу. Примерно это же и будет делать std::vector, но удалять из середины массива (вектора) есть вселенское зло.

#4
16:18, 28 янв 2008

mirat
> Почему нет?
Потому, что исходный вопрос автора был «можно мне как-нибудь так хитро вызвать delete, чтобы массив сам сделал всё как надо ?»
И с этой позиции вариант
> Можно удалить элемент, потом вручную сдвинуть все элементы с удаленной позиции на единицу.
не катит.
Вот вектор — да, целостная сущность, обладающая нужным функционалом.

#5
16:30, 28 янв 2008

по поводу
стоимость операции удаления буде линейно зависить от кол-ва элементов?

#6
16:59, 28 янв 2008

HolyDel
Из середины да, из конца — константное время.

Nikopol
Не телепат, не знаю, что автор имел в виду 🙂

#7
17:03, 28 янв 2008

Все понятно. Всем спасибо

#8
17:17, 28 янв 2008

если удалять, то уж лучше std::list использовать.

#9
17:33, 28 янв 2008

замечу только что если порядок элементов в массиве не важен то делать своп с последним элементом + pop_back => константное время удаления

• TaurenChief
• Постоялец

#10
17:42, 28 янв 2008
#11
17:52, 28 янв 2008
#12
18:24, 28 янв 2008

JokerR
>замечу только что если порядок элементов в массиве не важен то делать своп с последним элементом + pop_back => константное время удаления

Но размер вектора не уменьшится (резервированный в памяти)

#13
19:18, 28 янв 2008

О. Федор
А что должен? Он у вектора не уменьшится в любом случае, кроме хака со swap’ом

#14
19:21, 28 янв 2008

вообще-то это implementation-depended

Как удалить динамический массив c

Кроме отдельных динамических объектов в языке C++ мы можем использовать динамические массивы. Для выделения памяти под динамический массив также используется оператор new , после которого в квадратных скобках указывается, сколько массив будет содержать объектов:

int *numbers ; // динамический массив из 4 чисел // или так // int *numbers = new int[4];

Причем в этом случае оператор new также возвращает указатель на объект типа int — первый элемент в созданном массиве.

В данном случае определяется массив из четырех элементов типа int, но каждый из них имеет неопределенное значение. Однако мы также можем инициализировать массив значениями:

int *numbers1 >; // массив состоит из чисел 0, 0, 0, 0 int *numbers2 >; // массив состоит из чисел 1, 2, 3, 4 int *numbers3 >; // массив состоит из чисел 1, 2, 0, 0 // аналогичные определения массивов // int *numbers1 = new int[4]<>; // массив состоит из чисел 0, 0, 0, 0 // int *numbers1 = new int[4](); // массив состоит из чисел 0, 0, 0, 0 // int *numbers2 = new int[4]< 1, 2, 3, 4 >; // массив состоит из чисел 1, 2, 3, 4 // int *numbers3 = new int[4]< 1, 2 >; // массив состоит из чисел 1, 2, 0, 0

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

Стоит отметить, что в стандарт С++20 добавлена возможность выведения размера массива, поэтому, если применяется стандарт С++20, то можно не указывать длину массива:

int *numbers >; // массив состоит из чисел 1, 2, 3, 4

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

int *numbers >; // получение элементов через синтаксис массивов std::cout 
Причем для доступа к элементам динамического массива можно использовать как синтаксис массивов ( numbers[0] ), так и операцию разыменования ( *numbers )
Соответственно для перебора такого массива можно использовать различные способы:






unsigned n< 5 >; // размер массива int* p < new int[n] < 1, 2, 3, 4, 5 >>; // используем индексы for (unsigned i<>; i < n; i++) < std::cout std::cout ; i < n; i++) < std::cout std::cout ; q != p + n; q++) < std::cout std::cout 
Обратите внимание, что для задания размера динамического массива мы можем применять обычную переменную, а не константу, как в случае со стандартными массивами.
Для удаления динамического массива и освобождения его памяти применяется специальная форма оператора delete :






delete [] указатель_на_динамический_массив;
#include int main() < unsigned n< 5 >; // размер массива int* p < new int[n] < 1, 2, 3, 4, 5 >>; // используем индексы for (unsigned i<>; i < n; i++) < std::cout std::cout


Чтобы после освобождения памяти указатель не хранил старый адрес, также рекомендуется обнулить его:
delete [] p; p = nullptr; // обнуляем указатель
Многомерные массивы
Также мы можем создавать многомерные динамические массивы. Рассмотрим на примере двухмерных массивов. Что такое по сути двухмерный массив? Это набор массив массивов. Соответственно, чтобы создать динамический двухмерный массив, нам надо создать общий динамический массив указателей, а затем его элементы - вложенные динамические массивы. В общем случае это выглядит так:
#include int main() < unsigned rows = 3; // количество строк unsigned columns = 2; // количество столбцов int** numbers>; // выделяем память под двухмерный массив // выделяем память для вложенных массивов for (unsigned i<>; i < rows; i++) < numbers[i] = new int[columns]<>; > // удаление массивов for (unsigned i<>; i < rows; i++) < delete[] numbers[i]; >delete[] numbers; >
Вначале выделяем память для массива указателей (условно таблицы):






int** numbers>;
Затем в цикле выделяем память для каждого отдельного массива (условно строки таблицы):
numbers[i] = new int[columns]<>;
Освобождение памяти идет в обратном порядке - сначала освобождаем память для каждого отдельного вложенного массива, а затем для всего массива указателей.






Пример с вводом и выводом данных двухмерного динамического массива:
#include int main() < unsigned rows = 3; // количество строк unsigned columns = 2; // количество столбцов int** numbers>; // выделяем память под двухмерный массив for (unsigned i<>; i < rows; i++) < numbers[i] = new int[columns]<>; > // вводим данные для таблицы rows x columns for (unsigned i<>; i < rows; i++) < std::cout ; j < columns; j++) < std::cout > numbers[i][j]; > > // вывод данных for (unsigned i<>; i < rows; i++) < // выводим данные столбцов i-й строки for (unsigned j<>; j < columns; j++) < std::cout std::cout for (unsigned i<>; i < rows; i++) < delete[] numbers[i]; >delete[] numbers; >
Пример работы программы:
Enter data for 1 row 1 column: 2 2 column: 3 Enter data for 2 row 1 column: 4 2 column: 5 Enter data for 3 row 1 column: 6 2 column: 7 2 3 4 5 6 7
Указатель на массив
От типа int** , который представляет указатель на указатель (pointer-to-pointer) следует отличать ситуацию "указатель на массив" (pointer to array). Например:
#include int main() < unsigned n; // количество строк int (*a)[2] = new int[n][2]; int k<>; // устанавливаем значения for (unsigned i<>; i < n; i++) < // устанавливаем данные для столбцов i-й строки for (unsigned j<>; j < 2; j++) < a[i][j] = ++k; >> // вывод данных for (unsigned i<>; i < n; i++) < // выводим данные столбцов i-й строки for (unsigned j<>; j < 2; j++) < std::cout std::cout // удаляем данные delete[] a; a = nullptr; >
Здесь запись int (*a)[2] представляет указатель на массив из двух элементов типа int. Фактически мы можем работать с этим объектом как с двухмерным массивом (таблицей), только количество столбцов в данном случае фиксировано - 2. И память для такого массива выделяется один раз:
int (*a)[2] = new int[n][2];
То есть в данном случае мы имеем дело с таблице из n строк и 2 столцов. Используя два индекса (для строки и столца), можно обращаться к определенному элементу, установить или получить его значение. Консольный вывод данной программы:
1 2 3 4 5 6
Динамические массивы и переменные в C++: легко и просто!
 
Всем привет! В этой статье мы создадим массив и переменные применяя указатели. Если вы еще не почитали прошлую (начальную) статью про указатели, то советуем сначала изучить ее. Ну а если вы это все знаете, то погнали!
Что такое динамические переменные

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


Похожие публикации:

Td colspan 2 что это
Как стать инженером программистом
Какое значение имеет служебное слово const
Чем ядра отличаются от потоков