Встала проблема передать двумерный массив в функцию.

Здесь часто поднимались схожие вопросы, но ... не нашел ниодного подходящего ответа



Вот примерно так я планировал передовать массив, передавая в функцию указатель на массив указателей, размер по Y и по X

Как я думаю при преобразовании двумерного массива к указателю int** происходит затерание ячеек Mas[j], т.е. там появляются нулевые указатели

Как правильно здесь выкрутиться

С динамическими массивами работать не хочу

или 

там нет указателей и появлятся им неоткуда!
Mas - это не массив указателей... это двумерный массив... разница колоссальная...
ты можешь передать массив определённой размерности с произвольной последней размерностью...
void func (int Mas [][X])

Это сообщение отредактировал(а) archimed7592 - 18.4.2007, 17:57

archimed7592, 
не согласен.
Двумерный массив это массив массивов. И интерпретируеться как
*(*(Mas + X) + Y)
Где наглядно можно понять, что все такие это массив указателей...
Но ничего не затераеться.
И Mas[1] - хранит указатель на Mas[1][0]
  Mas[2] - хранит указаьель на Mas[2][0]

Это сообщение отредактировал(а) HappyLife - 18.4.2007, 18:23

Нет! 
HappyLife, юзай поиск по форуму. Не раз уже подобная тема поднималась.

Можешь и так - так сможешь мочить указатель 

JackYF, в этом

он прав

При передаче одномерного массива в фунцию в качестве фактического параметра нет разницы как мы объявили оный - int [] arr или int* arr, так как в любом случае будет неявное преобразование int [] в int*. Разница есть при передаче многомерных массивов - в случае с двумерным массивом при int arr [][X] в функцие он будет интепретироваться как (*)[X], то есть sizeof(arr[0][0] / sizeof(int)) выдаст количество элементов в строке.
Или я не понял о чем спор 

Это сообщение отредактировал(а) Xenon - 18.4.2007, 19:21

  
а в случаи если массивы находятся в Динамической памяти то


Добавлено через 1 минуту и 45 секунд

опять не доглядел 

Добавлено через 2 минуты и 24 секунды

  

Это сообщение отредактировал(а) betal - 18.4.2007, 21:36

HappyLife, 
согласен... "хранит"...
может быть скажешь мне тогда какой тип у этого указателя?
а лучше ничего не говори - покажи на деле:
1. какой должен быть тип someType (помимо того, что это указатель)?
2. где "хранится" этот указатель?
3. 
4. 

если ещё остались вопросы, дам тебе ссылку на тему из около 20 страниц... может хоть она избавит тебя от твоих илюзий...

Добавлено через 2 минуты и 38 секунд
почему вдруг ф-ция изменится, если массив будет в Динамической памяти (я так понимаю ты о new/delete говоришь)?

да не прав
двумерный массив N x M (type array[N][M]) - это одномерный массив длины N * M, и доступ к элементу (i, j) осуществляется как array + i * M + j

Это сообщение отредактировал(а) MAKCim - 18.4.2007, 22:05

Да нигде он не хранится! Он вычисляется сразу!

Двумерный массив можно рассматривать как массив одномерных массивов. Это четко прописано в стандарте.

Уже много раз на эту тему спорили.



Это абсалютно допустимая операция, pointer указатель и получает значение адреса 1-й строчки. Этот адрес в случае статического массива нигде не хранится, а вычисляется на этапе компиляции - так как базовый адрес массива известен.

В случае динамического определения массива делают так:



Все нормально компилируется и понимается как надо.

Это мы представляем двумерный массив в виде таблицы, а 3-хмерный в виде куба, а ведь это одномерный вектор памяти, так ?

он может вычислиться только при условии, что mas находится не в стеке
в случае стека до выполнения esp неизвестен

Добавлено через 1 минуту и 12 секунд

в случае type array[X1][X2]...[Xn], где Xi - константы, да

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

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

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

На примере двухмерных массивов:
Мнение, что адрес элемента массива вычисляется как БАЗА + Размерность1*Индекс1+размерность 2 правильное только в отношении статических массивов. Для динамических адрес элемента = Указатель[Индекс1]+Индекс2

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

Добавлено @ 22:22

для статических тоже:

Это сообщение отредактировал(а) archimed7592 - 18.4.2007, 22:24

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

с этим полностью согласен...

А как динамический двумерный массив создаете вы? Есть принципиально другой метод? (без шаблонов, разумеется) Чтобы потом обращаться к нему с помощью стандартного синтаксиса?

ну я ж тебе показал... могу ещё раз:
суть то не в этом 
суть в том, что двумерный массив, вне зависимости от его месторасположения (automatic/static/dynamic storage duration), передают в ф-цию одинакового...

Спасибо братки) Поддержали  

Это сообщение отредактировал(а) HappyLife - 19.4.2007, 09:21

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

А каким образом вы создадите динамически двумерный массив, где оба измерения динамические?


Это естественно. Главное знать границы

ну раз теория, тогда каждый элемент в двумерном массиве является просто элементом определенного типа, а не массивом как сказал ты, это раз
во-вторых массив - понятие обобщенное, одномерный, двумерный и т.д массивы - частные случаи массива как линейной последовательности элементов, на которой можно задать функции вида F(i): X -> Y(i), где i - количество индексов, X - исходная последовательность, Y - функция от количества индексов в массиве
т. е F(2) = X -> Y(2) (каждому элементу из X поставим в соответствие элемент из Y(2) = {a1 * N2 + a2}, где N2 - вторая размерность массива, a1, a2 - индексы), аналогично, F(3) = X -> Y(3) (Y(3) = {a1 * N3 + a2 * N2 + a3}), продолжая, получим
Y(i) = {a1 * Ni + a2 * Ni-1 + ... + ai}

Он располагается в физической памяти как одномерный массив. Ибо по другому он не умеет.
Суть только в адресах. И в адресах которые хранят указатель на другие адреса.
Дабы правильно увидеть это представляй его в виде таблици или куба.   

Что-то на счет теории я недопониаю. Существует отдельная теория о массивах?
Например в языке Бейсик прямо в описании языка говорилось, что двумерный массив представляет собой большой одномерный.
А в описании Си говорится, что многомерный массив - это массив массивов и совсем необязательно, что он занимает единый блок памяти.

Тут речь идет не о теории, а о конкретной реализации способа хранения многомерных массивов. В языке Си их по сути 2. Но смысл массива от этого не меняется.

вот и славненько 
ты наверное забыл с чего всё началось  :

Начнем с того в чем разница между переменной и массивом ?!?
В том что массив хранит в себе массив переменных одного типа.

Что-то тип того по имени мы получаем доступ к началу (адресу) первого элемента массива. А номер уже указывает на адресс массива + его порядковый номер в этом массиве

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

Добавлено через 1 минуту и 21 секунду
массив - это тип... абстракция... переменная - сущность...

Давайте закончим сыр бор на пустом месте.
Ведь достаточно открыть Страуструп 3 издание, приложение B раздел 7. Где все это описано.

  

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

это там ты вычитал про то, что в a[i] хранится указатель?  

Вовсе нет, я имею в виду 2 способа хранения. Если честно, я не лез в ассемблерный код, к какому общему виду приводит компилятор работу с массивом, но думаю все-таки к варианту динамического создания. Я говорю про способ извлечения конкретного элеменгта массива.

Допустим мы имеем статический массив
int a[4][6];

Потом получаем доступ к элементу:
a[2][3] = 1;

Как компилятор получает доступ к такому элементу? Если рассматривать массив как единый блок памяти, то очень просто:
a + (6 * 2) + 3; - Получаем адрес искомого элемента

Если рассуждать с точки зрения массива указателей, то алгоритм рассчета несколько другой (тоже очень просто):
a[2] + 3;

Я на 99% уверен, что компилятор в конечном итоге рассчитывает адрес именно по второму способу - так как он более общий. А в случае статического массива указатели физически хранить не надо, а их можно вычислить.


А по вашему что там?
int a[3][4];
int *p;

p = a[2];

Какое значение получит p, как не указатель? Другой вопрос, что физически он может там и не храниться.

ну эт типа сказать, что sum(2,3) хранит число 5...

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

А при чем это здесь? Вы говорите о указателе? Если ДА ?! ТО Общий вид будет примерно таков
*(p+2); - это в случаи если массив одномерний 
а здесь будет немного другой вид

Добавлено через 30 секунд

  

Я про это и говорю. 
В случае с двумерными массивами по первому измерению находятся именно указатели. И необязательно подряд. Храняться они там или вычисляются по ходу пьесы зависит от способа объявления массива не более того.

Предложенные варианты

и

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

где m - количество элементов в строке матрицы.
Однако адресация внутри функции f при таком варианте изменится
с 

на 


Ну и не могу не вмешаться.
Часть неразберихи вызвана путаницей.
Я вижу 3 ветки обсуждений :
1. Что такое статический и динамический двумерный массив в понимании c++.
2. Что такое одномерная и двумерная матрица в линейной алгебре.
3. Что такое статический и динамический двумерный массив в понимании мэнэджера памяти с++.
Нельзя сравнивать вещи из разных "веток" обсуждений.

Это сообщение отредактировал(а) dizzy1984 - 19.4.2007, 11:53

Мой вариант:

Массив динамический, размерность - любая


Доступ к элементу массива - как обычно var[a][b]

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

передавай, что душе угодно

Задал простой вопрос, так все стали флудить вокруг да около... :( 
Устал читать

В понимании языка С/С++ двумерный массив это массив массивов, то есть массив указателей на массивы. 
Я думаю многие работали на Бейсике (хотя бы в школе), в котором двумерный массив это единый участок в памяти
если приветси псевдокод
Mas = array [Y][X]
0 < i < X 
0 < j < Y
То благодоря последовательному размещению в памяти можем обратиться к ячейке памяти
Mas[j][i] == Mas[1][(j-1)*X+i]


Возвращаясь на язык С/С++
Буду рассматривать именно бейсиковский двумерный массив
Mas[j][i]
*(Mas+j)[i]
*(*(Mas+j)+i)
-----
int(  Mas+j*X+i  )
Mas[0][j*X+i]

Проблема в другом
Необходимо правильно указать компилятору, что передается указатель(4-х байтный адрес)начала массива массивов

Как правильно преобразовать тип из бейсиковского двумерного массива [][] к указателю **

Это сообщение отредактировал(а) neosapient - 19.4.2007, 14:19

Короче, воспользовался 
int Mas[Y][X]
int* pMas = (int*)Mas;
обращение к ячейки
*(  Mas+j*X+i  )


А все навороты делает компилятор

Логически разницу между бейсиковским и сишным двумерными массивами могу сравнить с борьбой конструкций IF...THEN...ELSE   и   SWITCH...CASE...BREAK
Я имею в виду (для тех немногих, что не знают), что при использовании  SWITCH...CASE...BREAK компилятор не преобразует к дереву из элементов IF...THEN...ELSE, а создает сводную таблицу переходов...

neosapient, делай так:


Добавлено через 1 минуту и 33 секунды
смотрю, так и сделал 

Добавлю.
Так передавать можно только статический массив или динамический, созданный как одномерный. 

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

в книгах по С/С++ такое и не должно быть написано

в чем я не прав по пунктам?

Это сообщение отредактировал(а) MAKCim - 19.4.2007, 19:11

 неа, sizeof приводится к константе на этапе компиляции.

 А разве элементы расположены не подряд? Нас учили, что ВСЕГДА подряд.

nerezus, какая разница принципиальная?