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

Создание двумерного динамического массива

Как создать двумерный динамический массив так, чтобы можно было получать доступ как к статическому Array[a][b] ?

Отслеживать
219k 15 15 золотых знаков 119 119 серебряных знаков 230 230 бронзовых знаков
задан 15 дек 2011 в 13:10
1,287 12 12 золотых знаков 36 36 серебряных знаков 62 62 бронзовых знака

3 ответа 3

Сортировка: Сброс на вариант по умолчанию

Это тема здесь как-то уже поднималась. Но напишу еще раз. Создать массив int 10×20 Способ 1

const int x = 10, y = 20; int ** array = (int**) malloc (sizeof (int*) * x); for (int i = 0; i

Обращаться к элементам такого массива можно array[m][n]

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

int * array = (int*) malloc (sizeof(int)*x*y);

Но обращаться к его элементy [m][n] можно только так:

int a = *(array + y*m + n);

Отслеживать
ответ дан 15 дек 2011 в 13:19
23.9k 2 2 золотых знака 37 37 серебряных знаков 69 69 бронзовых знаков
неплохо) спасибо )
15 дек 2011 в 13:23

Кстати, массивы небольшого размера, который неизвестен во время компиляции, можно создавать и на стеке. Для этого нужно заменить malloc на alloca. И освобождать его не нужно. При возврате из функции он сам удалится.

15 дек 2011 в 16:07
угу. тоже правильно.
15 дек 2011 в 16:37

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

Итак, вариант — который нужен в общем-то только для совместимости с объявлением обычного массива type array[Rows][Cols] —

type * array = new type[Rows*Cols]; // C++ type * array = malloc(sizeof(type)*Rows*Cols); // C

Освобождение памяти простейшее —

delete[] array; // C++ free(array); // C

Плюс: совместимость по схеме размещения в памяти с обычным массивом. Минус: обращение array[r][c] не работает — только array[r*Cols+c] или *(array+r*Cols+c) .

Варианты, допускающие обращение array[r][c] — но сразу же предупреждение: несовместимы с размещением в памяти обычного массива. Легкий минус всех их — двойное косвенное обращение.

// C++ type ** array = new type*[Rows]; for(size_t i = 0; i < Rows; ++i) array[i] = new type[Cols]; . for(size_t i = 0; i < Rows; ++i) delete[] array[i]; delete[] array; // C type ** array = malloc(sizeof(type*)*Rows); for(size_t i = 0; i < Rows; ++i) array[i] = malloc(sizeof(type)*Cols); . for(size_t i = 0; i < Rows; ++i) free(array[i]); free(array);

Обращение к элементам массива - array[r][c] .

Если немного подумать, то в варианте для С, где нет никаких конструкторов-деструкторов, можно упростить освобождение памяти:

// C type ** array = malloc(Rows*(sizeof(type*) + sizeof(type)*Cols)); for(size_t i = 0; i < Rows; ++i) array[i] = ((unsigned char*)array +sizeof(type*)*Rows+i*sizeof(type)*Cols); . free(array);

Плюс один - очистка памяти в одно касание. Минусы - возможные проблемы выравнивания, возможная проблема strict aliasing. Как мне кажется, реально проявляться не должны, но тем не менее буду признателен тем, кто покажет, как строго избавиться от проблем при сохранении функциональности.

Впрочем. еще есть и плюс второй:

type * a = (type*)((unsigned char*)array +sizeof(type*)*Rows);

совместим с массивом type a[Rows][Cols] по размещению в памяти. Так что с одним и тем же массивом можно работать и так, и эдак.

Еще одна экзотика - поскольку по указателю нельзя определить размеры массива.

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

T** create(int N, int M) < T** arr = (T**)malloc(2*sizeof(int)+N*(sizeof(T*)+M*sizeof(T))); *((int*)arr) = N; *((int*)arr+1) = M; arr = (T**)((char*)arr+2*sizeof(int)); for(int i = N, ofs = N*sizeof(T*); i-->0; ofs += M*sizeof(T)) arr[i] = (T*)((char*)arr + ofs); return arr; > void kill(T** arr) < free((char*)arr-2*sizeof(int)); >int rows(T**arr) < return *(int*)((char*)arr-2*sizeof(int)); >int cols(T**arr)

Все это относится только к C, потому что в С++ этих проблем нет - просто берем и объявляем

vertor> array(Rows,vector(Cols));

после чего есть все - и обращение array[i][j] , и нужные размеры -

Rows == array.size() Cols == array[0].size()

Нужно только следить, чтоб случайно не изменить размер какого-то из векторов.

Двумерный динамический массив

Создать двумерный массив (вводим матрицу с клавиатуры) если матрица квадратная то найти произведение под побочной диагонали матрицы, иначе найти модуль минимальный элемента матрицы если не понимаете объясню)) детально

int main() < int M ; int N ; int i, j; int** matrix; cin >> M; cin >> N; matrix = new int*[M]; for ( i = 0; i < M; i++) matrix[i] = new int[N]; for ( i = 0; i < M; i++) // ввод for ( j = 0; j < N; j++) < cout > matrix[i][j]; > cout cout

Вот вводим двумерный динамический массив а как посчитать ниже побочной матрицы диагональ напишите пожалуйста я как бы знаю как но в программе не могу написать это

Я вот читаю некоторые посты и просто охреневаю: написано то ли после доброго косяка, то ли после 0,5 на рыло.

(1) найти произведение под побочной диагонали матрицы
(2) как посчитать ниже побочной матрицы диагональ

И что тебе таки надо, Ангел за номером 143?

Макар вариант 1 и еще это задание дают учителя) а не мы сами придумываем я вот учусь на программиста знаю паскаль но нам дали задание сделать на си++ и я не знаю программу эту

Angel143, ты не находишь, что даже вариант 1 выглядит несколько странно, хотя догадаться, что там написано, можно. Я не думаю, что ваши учителя вам дают именно так сформулированное задание.

Отмаз как на Паскале — знаю, а на С++ — «сами мы не местные» — не прокатывает. Напиши рабочий вариант программы на Паскале, а на С++ перевести — не проблема, поможем.

Кстати кусок программы с вводом значений и распечаткой — вполне ничего себе. Только с форматированием кода сбился.

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

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

222, почитайте здесь

Angel143, не знаю кто тебе так дает, но от твоей орфографики я офигеваю.

Дальше — ни хрена не понял:

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

Ты можешь написать код? или НЕ можешь? Хотя бы на Паскале. Видимо, «могу, но забыл как».

Лови кусок кода «для нахождение произведение под побочной диагонали матрицы», если я вообще понял, чего ты хочешь.

Внимание! Это довольно старый топик, посты в него не попадут в новые, и их никто не увидит. Пишите пост, если хотите просто дополнить топик, а чтобы задать новый вопрос — начните новый.

Динамический массив в С++

Динамическое выделение памяти необходимо для эффективного использования памяти компьютера. Например, мы написали какую-то программку, которая обрабатывает массив. При написании данной программы необходимо было объявить массив, то есть задать ему фиксированный размер (к примеру, от 0 до 100 элементов). Тогда данная программа будет не универсальной, ведь может обрабатывать массив размером не более 100 элементов. А если нам понадобятся всего 20 элементов, но в памяти выделится место под 100 элементов, ведь объявление массива было статическим, а такое использование памяти крайне не эффективно.

В С++ операции new и delete предназначены для динамического распределения памяти компьютера. Операция new выделяет память из области свободной памяти, а операция delete высвобождает выделенную память. Выделяемая память, после её использования должна высвобождаться, поэтому операции new и delete используются парами. Даже если не высвобождать память явно, то она освободится ресурсами ОС по завершению работы программы. Рекомендую все-таки не забывать про операцию delete .

// пример использования операции new int *ptrvalue = new int; //где ptrvalue – указатель на выделенный участок памяти типа int //new – операция выделения свободной памяти под создаваемый объект.

Операция new создает объект заданного типа, выделяет ему память и возвращает указатель правильного типа на данный участок памяти. Если память невозможно выделить, например, в случае отсутствия свободных участков, то возвращается нулевой указатель, то есть указатель вернет значение 0. Выделение памяти возможно под любой тип данных: int, float,double, char и т. д.

// пример использования операции delete: delete ptrvalue; // где ptrvalue – указатель на выделенный участок памяти типа int // delete – операция высвобождения памяти

Разработаем программу, в которой будет создаваться динамическая переменная.

// new_delete.cpp: определяет точку входа для консольного приложения. #include "stdafx.h" #include using namespace std; int main(int argc, char* argv[]) < int *ptrvalue = new int; // динамическое выделение памяти под объект типа int *ptrvalue = 9; // инициализация объекта через указатель //int *ptrvalue = new int (9); инициализация может выполнятся сразу при объявлении динамического объекта cout

MNorin.com

Блог про Linux, Bash и другие информационные технологии

Двумерный динамический массив в C/C++

Пример двумерного динамического массива.
Этот пример скорее больше подходит для классического Си, но принцип создания динамического двумерного массива в этом примере достаточно прозрачен, что позволяет на его основе использовать, скажем, операторы потоков ввода-вывода cin и cout.
Функция realloc(), которая использована в листинге программы, может быть использована для увеличения уже выделенного участка памяти, а для освобождения памяти может быть использована функция free().

Прототипы функций для работы с динамической памятью, расположенные в модуле stdlib:

#include void *malloc (size_t size); void *calloc (size_t num, size_t size); void *realloc(void *block, size_t size); void *free(void *block);

Собственно, сам пример программы:

#include #include void main() < // *** Variables *** int** ArrayRoot; int i,j; int LinesCount,NumbersCount; // *** Program code *** // Input size of array printf("Enter count of lines: "); scanf("%d",&LinesCount); printf("Enter count of numbers in line: "); scanf("%d",&NumbersCount); // Print entered size printf("Array size: %dx%d\n",LinesCount,NumbersCount); // Create array of int* - allocate memory ArrayRoot= (int **)malloc(sizeof(int*)*LinesCount); // for every pointer to int for (i=0;i; >; for (i=0;i; >; // Free memory for (i=0;i; // Clear memory user by pointer to integer pointers ArrayRoot=(int **)realloc(ArrayRoot,0); >

Результат работы программы:

Enter count of lines: 3 Enter count of numbers in line: 2 Array size: 3x2 Enter Array [0,0]: 1 Enter Array [0,1]: 2 Enter Array [1,0]: 3 Enter Array [1,1]: 4 Enter Array [2,0]: 5 Enter Array [2,1]: 6 Array [0,0]: 1 Array [0,1]: 2 Array [1,0]: 3 Array [1,1]: 4 Array [2,0]: 5 Array [2,1]: 6