Снова "многомерные" массивы (вырезка)

[nikedeforest]

Код:

#include <conio.h>
#include <iostream.h>
#include <values.h>
#include <limits.h>

int calc (int **mass)
{
 
 for (int j=0; j<4; j++)
 {  
        for (int i=0; i<3; i++)
        {
              if (mass[i][j]==0)
              {
                return j;
              }  
         }
 }
return -1;
}

попробуй это вставить. Помни, что нумерация начинается с 0.
А ошибки у тебя 2 было,
одна:
int *calc (int **mass)
А возвращала ты целое число, а не указатель, т.е. return k;
А другая логическая. Оператор break не спас бы тебя, из одного цикла ты выйдешь, а из другого (внешнего) нет.

[Джон]

"И раскроются все тайны и чудеса, поскольку постигнуты будут естественные причины их…"
Френсис Бэкон

Ещё раз в С++ нет двумерных массивов!!! Все данные записаны в памяти последовательно. Поищи на форуме. Уже было обсуждение этого вопроса.

Вот эту 2 4 7 8 9 3 5 0 3 7 0 6 запись я могу представить, как

2 4 7 8
9 3 5 0
3 7 0 6

или как

2 4 7
8 9 3
5 0 3
7 0 6

Как видишь, в одном случае второй и четвёртый столбец содержат 0, а во втором только второй.

для наглядности  - вот так расположены данные в памяти для двух массивов:

int mass[3][4]={4,7,9,1,3,0,2,4,6,8,0,5};
int mass1[12]={4,7,9,1,3,0,2,4,6,8,0,5};

0012F714  04 00 00 00 07 00 00 00 // mass
0012F71C  09 00 00 00 01 00 00 00
0012F724  03 00 00 00 00 00 00 00
0012F72C  02 00 00 00 04 00 00 00
0012F734  06 00 00 00 08 00 00 00
0012F73C  00 00 00 00 05 00 00 00
0012F744  04 00 00 00 07 00 00 00 // mass1
0012F74C  09 00 00 00 01 00 00 00
0012F754  03 00 00 00 00 00 00 00
0012F75C  02 00 00 00 04 00 00 00
0012F764  06 00 00 00 08 00 00 00
0012F76C  00 00 00 00 05 00 00 00

Как видишь - никакой разницы.

[nikedeforest]

Джон, имхо ты не прав или не корректен.
Двухмерные массивы  есть не только в С++, но и в С. А тот момент, как элементы массива расположены в памяти не имеет значения, важно помнить лишь, что элементы массива расположены последовательно. Двухмерный массив  с языке С/С++ - это массив указателей. Вспомним динамическое выделение памяти

Код:

int **arr;
//cоздаем массив указателей
arr=new int * [4];
//а теперь от каждого указателя создаем еще массив
arr[i]=new int [4];

Важно помнить, что указатель хранит в себе адрес на участок в памяти, т.е. когда мы пишим
arr[ i ]=new int [4];
то на самомо деле происходит присвоение каждому элементу массива arr[] адреса на участок памяти с которого начнется еще один массив. Да в памяти элементы массива расположутся не ввиде матрицы, а полседовательно, при этом не стоит  думать, что за последним элементом массива arr[0] будет находиться первый элемент массива arr[1]. Такой гарантии никто не даст, но дадут гарантию, что все элементы массива arr[0] будут расположены последовательно, не фрагментировано, тоже самое для элементов массивов arr[1], arr[2], arr[3] и т.д.
В С/С++ есть не только двухмерные массивы, но и многомерные.
Вот такое мое имхо, извините, если что не так.

[Dimka]

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

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

Возможна передача массива в качестве параметра функции, но лишь одномерного массива.

Код:

void f(int a[]) { ... }
...
int a[10];
f(a);

На уровне комплиятора C передача массивов с количеством размерностей более 1 решается только при явном задании всех размерностей кроме последней.

Код:

void f(int a[10][]) { ... }
...
int a[10][10];
f(a);

Связано это с алгоритмом преобразования оператора [] в значение на этапе компиляции. На уровне машинного кода массивов как понятия нет вообще, есть лишь указатели и участки непрерывной памяти под массивы.

Выделение памяти всегда последовательно: за последним элементом a[0][] всегда идёт первый элемент a[1][].

[Dimka]

Примечание: выделение памяти последовательно лишь в статических массивах (размеры которых определены на этапе компиляции), для динамических массивов это не обязательно.

Возможны операции с динамическими структурами как с массивами, в том числе создание многомерных "массивов" с переменным количеством элементов в измерениях. Например для "массива" a[10][] количество элементов в a[0] может быть 5, в a[1] - 2 и т.д.

[Dimka]

Алгоритм преобразования оператора [] в значение такой:

Код:

a[x][y]...[z] => *(...*(*(a+x)+y)+...+z)

[Джон]

nikedeforest, я не буду с тобой сейчас и в этой теме спорить по поводу N-мерных массивов. Тем более, что споры уже были. Я посмотрю темку, или сам поищи.
В данном случае важно понимание сути "строк" и "столбцов". Или это было не достаточно наглядно? Данные одни и те же. Каким образом ты получишь доступ к этим данным не важно. Но важно, то что ты считаешь столбцом и строкой в ОДНОМЕРНОМ массиве.

ps В принципе тоже самое, что dimka сказал только "моими" словами.

[Джон]

Если тема так интересна и актуальна - надо найти старую тему и перенестись туда.

[nikedeforest]

НЕ думал, что есть по этому поводу споры, ну да ладно. Спорить сейчас и мне не под силу, к тому же не тостаточно компетентности, чтобы с вами спорить. Темку как-нибудь поищу, но не сейчас.
Просто мне кажется вы людей путаете такими высказываниями. Я не видел ни одной книги по С/С++ где бы не было заголовка "Двухмерные массивы" или "Многомерные массивы". Надо посмотрить есть ли этот момент в стандарте. Ну спорить не буду, да и есть ли смысл, как я понимаю этот вопрос почти что из ряда философских, типа "Что раньше - яйцо или курица?"

[Dimka]

nikedeforest, совершенно не понял, о чём ты говоришь. К проблеме "курицы и яйца" описанное никакого отношения не имеет, к стандарту тоже (за исключением вопросов декларации массивов, передачи массивов как параметров и обработки оператора []).

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

Вот рабочий пример на Borland C++ 3.1:

Код:

#include <stdio.h>

#define N 10

typedef int line_array[N * N];
typedef int square_array[N][N];

int main()
{
	int i, j;
	line_array a;
	square_array *b;

	printf("A 1D array:\n");
	for(i = 0; i < N * N; ++i)
	{
		a[i] = i;
		printf("%4i", a[i]);
	}
	printf("\n");

	b = (square_array *)&a;

	printf("A 2D interpretation of the array:\n");
	for(i = 0; i < N; ++i)
	{
		for(j = 0; j < N; ++j)
			printf("%4i", (*b)[i][j]);
		printf("\n");
	}

	return 0;
}

В примере можно ввести ещё множество типов int[5][20], int[25][4] и т.д., и работать с их помощью всё с тем же массивом int[100].

[Dimka]

Слово "массив" - это не понятие некоторого языка программирования, это понятие программирования. В развитых языках это понятие реализовано в виде соответствующих языковых конструкций, в неразвитых - программист сам для себя решает, как организовать массив при помощи имеющихся языковых средств.

В C/C++ понятие "массив" имеет смысл участка памяти, заполненного единицами данных одного типа. Всё остальное - размерность массивов, оператор [], динамические массивы, строки - это лишь надстройки для удобства программиста, "артефакты". Говорить, что их не существует, не имеет смысла, т.к. ими повсеместно пользуются. Говорить, что это основные языковые понятия, будет неверно.

Поэтому спор о том, существуют многомерные массивы "на самом деле" или не существуют, бессмысленен, т.к. не определено "самое дело" - смысловая область приложения этого спора.

[nikedeforest]

Ну не знаю. Я все прекрасно понимаю, что вы мне говорите, ну не могу сказать, что я совсем согласен.
Мне, например, не нравится этот момент

В C/C++ понятие "массив" имеет смысл участка памяти, заполненного единицами данных одного типа. Всё остальное - размерность массивов, оператор [], динамические массивы, строки - это лишь надстройки для удобства программиста, "артефакты". Говорить, что их не существует, не имеет смысла, т.к. ими повсеместно пользуются. Говорить, что это основные языковые понятия, будет неверно.

Вот не согласен я тут.
Вот как я мыслю. Если бы не было реализации этого, то можно было бы сказать, к примеру, "В С/С++ нет строк". А то, что можно самому этот механизм реализовать это дело левое.
Т.е. я как считаю, язык реализовал возможность, значит в нем это есть, не реализовал - нет. А то, что программист может создать то, чего нет, об этом речи не веду.
А Джон как раз и написал: "Ещё раз в С++ нет двумерных массивов!!! "
Но с другой стороны, я согласен, что

В C/C++ понятие "массив" имеет смысл участка памяти, заполненного единицами данных одного типа.

И я врезультате в замешательстве. И скорее всего замешательство это вызвано какой-то неопределенностью, твоими словами

Поэтому спор о том, существуют многомерные массивы "на самом деле" или не существуют, бессмысленен, т.к. не определено "самое дело" - смысловая область приложения этого спора.

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

[Джон]

"Ах оставьте ненужные споры - я себе уже всё доказал" (с)

Сразу скажу я не против термина "двумерный", как Димка правильно сказал - для программиста удобней ползоваться этим термином. Дело в следущем - по условию задания надо просканировать матрицу NxM и выдать индекс по условию. ЧТО МОЖЕТ БЫТЬ ПРОЩЕ? Практически любая операция обращения к данным в виде матрицы связана с этим.
Те для меня на лицо явное непонимание основных принципов организации данных. Это не проблема языка, а проблема понимания. Поэтому и эпиграф в первом топике и провоцирующая инфа - "двумерных массивов нет". Я ожидал реакции - "да я это знаю, у меня проблема в другом".  Всё-таки человек занимается програмированием и только готовыми штампами здесь не обойтись.
Поэтому я и вопрос задал. И если человек затрудняется на него ответить, то значит проблема именно с пониманием внутренней организации данных. Согласись без этого понимания за функции обработки этих данных даже и браться не стоит. Исключение, конечно, если это нафиг не надо, а нужно просто готовое решение, чтобы получить зачёт.

Ну а про говорится, не говорится...  Яйцо, курица... Запутываем... Да нет, скорее наоборот разъясняем. Ведь на самом деле всё гораздо проще. Я не буду тебя убеждать, ты сам должен к этому прийти. Попытайся сначала ответить на пару вопросов.

Тебя вообще-то запись обращения к элементу не смущает? Например m[2][3].
Ведь если это многомерный массив, то логичней к нему было бы обращаться m[2,3]? Или? А дело в том, что "многомерные" массивы в С++ есть не что иное как массивы массивов. Явная формула записи существует, обращение к элементу m[ i ] [ j ] можно записать в виде *(*(m+i)+j). Те просто вычисление указателя на нужный блок памяти. Хотя про это тоже говорили.
К чему я это? А вот к чему - попробуй передать в функцию в качестве параметра двумерный массив, ну хотя бы m[2][3] - интересно как ты это сделаешь?

А темка тут - только вроде какие-то траблы с базой были или не совместимость с новым движком - там форматирование нарушено:
https://forum.shelek.ru/index.php/topic,1374.msg21182.html#msg21182

Там кстати на живом примере показано, как важно понимание сути.

зы Я потом эти топики туда перенесу. Ща со временем напряжёнка. Да и там заодно флуд подчистить надо. ИМХО тема заслуживает присутствия в FAQ.

[Джон]

Я в топик m[ i ] [ j ]  специально записал иначе просто i в квадратных скобках воспринимается как тег для курсива

[nikedeforest]

Да, Джон, ты прав. 
Но меня интересует такой момент, а в каком же языке  программирования тогда есть такое понятие "двухмерные массивы"? Запись m[2,3] не показатель на двухмерность, имхо. Насколько я помню в Паскале так пишится, но если выделять память динамически, то там кажется суть такая же как в С. Значит в Паскале этого термина тоже нет. А где тогда (интересно же)? Дело в том, что как ни крути, в памяти это будет записано последовательно (так сказать "в строку"), а не ввиде матрицы (имхо, это беспредел уже какой-то был бы). Или я тут ошибаюсь? Просто у меня пока, следуя вашим выводам, получается, что такого понятия и нет ни в каком языке.

Те для меня на лицо явное непонимание основных принципов организации данных. Это не проблема языка, а проблема понимания. Поэтому и эпиграф в первом топике и провоцирующая инфа - "двумерных массивов нет". Я ожидал реакции - "да я это знаю, у меня проблема в другом".  Всё-таки человек занимается програмированием и только готовыми штампами здесь не обойтись.
Поэтому я и вопрос задал.

Я согласен, что твой вопрос поставил Carrie Bradshaw в тупик и этот момент надо было проработать. Но как мне показалось у нее проблема была еще и в том, что она не совсем осмыслила свое решение. Вот этот момент

но вообще хотела, чтоб матрица считывалась не построчно, а по столбцам. как только найдет первый нулевой элемент, просто запоминает его второй индекс. вот и всё.

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

[Dimka]

К чему я это? А вот к чему - попробуй передать в функцию в качестве параметра двумерный массив, ну хотя бы m[2][3] - интересно как ты это сделаешь?

Пожалуйста (для Borland C++ 3.1):

Код:

#include <stdio.h>

#define N 2
#define M 3

void f(int m[N][M])
{
	int i, j;
	for(i = 0; i < N; ++i)
	{
		for(j = 0; j < M; ++j)
			printf("%2i", m[i][j]);
		printf("\n");
	}
}

int main()
{
	int m[N][M];
	int i, j, k = 0;
	for(i = 0; i < N; ++i)
		for(j = 0; j < M; ++j)
			m[i][j] = k++;
	f(m); 
	return 0;
}

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

[Джон]

Ха, весельчак. "Эт и я так могу" (с) Промокашка

Это разрешено делать, если на этапе трансляции известен размер массива. А ты попробуй с динамическим массивом - N и M переменные. Я имел ввиду конечно же двумерный массив - 2 и 3 были просто для примера.

Слабо записать void f(int m[][])? А?

[Dimka]

Слабо записать void f(int m[][])? А?

Может, несмотря на пыл споров, всё же будем внимательно читать, что друг другу пишем?

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

См. пост #102.

[Джон]

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

Как это ещё можно по другому понять? Какое ещё решение может быть, кроме цикла в цикле?

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

Ещё раз, не важно как это называется. Но если программист, работая с С++, представляет себе только прямоугольник с цифрами и ничего другого, то он уже не понимает, что делает.
Прямоугольные скобки в данном случае скорее сбивают с толку, чем помогают. Тк несут другую смысловую нагрузку - а именно левая показывает не столбец и не строку, а номер блока, который в свою очередь является массивом (хотя это и не обязательно). Что это? Строка? Столбец? Я не знаю. Да и компилятору по барабану. Это для него альтернативная запись доступа к блоку памяти и всё.
Те наше "математическое" обращение к элементам матрицы превращается в хитрую запись указателей. В этом и заключается сложность и проблематика. Именно к этому ты и должен был бы прийти. Поэтому это ИМХО очень важный вопрос.
ПРАВИЛЬНО ПОЛЬЗОВАТЬСЯ УКАЗАТЕЛЯМИ. Как показывает опыт проблемы кроются именно в этом.

Конечно я не могу тебе ответить как это реализовано в других языках. Для этого я должен их знать, хотя бы так же хорошо, как С++, который, честно говоря, я тоже желал бы знать лучше. Я не теоретик программирования. Подобные вещи я усвоил на своём опыте (не всегда сладком) и всегда об этом говорю.

Ещё раз сошлюсь на темку - ведь тоже простая ошибка. А сколько людей не знают о нашем форуме и ковыряются с подобными ошибками, только потому, что некий нерадивый препод по инфораматике в своё время привил уверенность к тому, что в С++ есть двумерные массивы типа m[строка][столбец]

[Джон]

Может, несмотря на пыл споров, всё же будем внимательно читать, что друг другу пишем?

Давай - начнём с того, что мой вопрос про передачу в ф-ю массива я адресовал nikedeforest, а не тебе. Ок?

Потом, то что ты написал отвлекает от темы, если ты внимательно читаешь мои топики. Тем более строго говоря твои примеры содержат ошибки. Но я опять таки не обращаю на них внимание, потому, что к пониманию вопроса это не относится

Вот так должно быть записано правильное решение

 (int** m, int N, int M)

Разобраться почему - оставляю как домашнее задание.


зы Конечно я не знаток именно Borland C++, но если он такое позоволяет, то это не говорит в его пользу.

[Алексей++]

Джон, dimka, спорить, НО только не ссориться!

[Джон]

А мы и не соримся. Или? Димка, если я тебя чем обидел - сорри. Не со зла я это. В моём #115 конечно не хватает смайлков. Это был не наезд, я просто прикололся. Тк ты предложил частное решение.
Ещё раз - я просто пытаюсь объяснить nikedeforest в чём поблема.
Да и спора собственно быть не может, мы с Димкой в принципе говорим об одном и том же. Повода для спора я не вижу.

Кстати, Лёшка ты очень к стати - если время есть - перекинь эти топики в темку линк на которую я дал. И в Чаво её родимую.

[nikedeforest]

Что-то и вправду как-то мы все друг друга не совсем понимаем, имхо .

Прямоугольные скобки в данном случае скорее сбивают с толку, чем помогают. Тк несут другую смысловую нагрузку - а именно левая показывает не столбец и не строку, а номер блока, который в свою очередь является массивом (хотя это и не обязательно). Что это? Строка? Столбец? Я не знаю. Да и компилятору по барабану. Это для него альтернативная запись доступа к блоку памяти и всё.
Те наше "математическое" обращение к элементам матрицы превращается в хитрую запись указателей. В этом и заключается сложность и проблематика. Именно к этому ты и должен был бы прийти. Поэтому это ИМХО очень важный вопрос.
ПРАВИЛЬНО ПОЛЬЗОВАТЬСЯ УКАЗАТЕЛЯМИ. Как показывает опыт проблемы кроются именно в этом.

Я пришел к тому, что человек не совсем понимает решение задачи.

что некий нерадивый препод по инфораматике в своё время привил уверенность к тому, что в С++ есть двумерные массивы типа m[строка][столбец]

Кхе, кхе. Не кипятись, Джон .
В руках держу чУдную книгу (имхо и без рекламы) "Полный справочник по С++ 4-е издание" автор Г. Шилдт.
Стоит отметить, что этот товарищ авторитетная личность, но я думаю ты знаешь .
Ну  так вот, у него есть заголовок "Двухмерные массивы".
начинается он так

В языке С/С++ предусмотрены многомерные массивы. Простейшим из них является двухмерный. По существу, двухмерный массив - это массив одномерных массивов.
...
...
В некоторых языках программирования размерности массивов отделяются запятыми. В отличие от  них в языке С/С++ размерности массива заключаются в квадратные скобки.

Думаю, не стоит считать шарлатаном каждого, кто использовал термин "Двухмерный массив" применительно к С/С++ в частности.
А то что студент(ка) не въехал в курс дела, это не всегда вина преподавателя. Человек не в состоянии поддерживать сконцетрированное внимание 45 мин. подряд, к тому же если лекция монотонна.   Поэтому фраза "двухмерный массив - это массив массивов" могла быть банально упущена студентом (даже при чтении написанного).
Ну и бывает, что и препод косячит, но не так это часто случается, особенно на таких этапах.

[Алексей++]

... перекинь эти топики в темку линк на которую я дал. И в Чаво её родимую.

если бы я знал, как перекинуть отдельные посты
(пока жду, когда расскажешь как, взял на заметку тему)

[Finch]

Джон, Кстати. Давно пора данный спор вывести за рамки данного топика и Borrland С++.

(голос из-за угла) В Обшение его, в обшение. А лучше всего в тему "ФЛУД 2006"

[Dimka]

Потом, то что ты написал отвлекает от темы

А, мешаю. Хорошо, могу подождать, пока до конца не изложат "правду жизни".

Тем более строго говоря твои примеры содержат ошибки.

Я не позволяю себе публиковать код, который не проверял на работоспособность. А если таковой код всё же публикую, всегда пишу в примечании, что не проверял. Вышеприведённый код гарантированно работает в Borland C++ 3.1, и работает без ошибок, утечек памяти и т.п. вещей. Поэтому давай без наездов - невежливо. Если строго говоря - сперва представь доказательства.

Вот так должно быть записано правильное решение

 (int** m, int N, int M)

Это "традиционная" запись - не отрицаю, но утверждать её как единственную абсолютную истину в последней инстанции несколько... самонадеянно, извини. Такая запись лишь более универсальна для функции, обрабатывающей массивы разных размеров. Лично у меня нет никаких религиозных причин отрицать альтернативные решения, если они уместны при решении задачи.

[nikedeforest]

Джон, ты не совсе прав, передавать надо по-разному, смотря что передавать будешь.
К примеру

Код:

void func1(int arr[][4], int n)
{
...
...
}
void main()
{
int arr[4][4];
func1(arr,4);
}

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

Код:

//Как правильно
void func1(int **arr, int n, int m)
{
...
...
}
void main()
{
int **arr;
arr=new int *[4];
for(int i=0;i<4;i++)
arr[i]=new int [4];
func1(arr,4,4);
}

,А вот палево

Код:

//Как неправильно, здесь мы пАлимся 
void func1(int arr[4][4])
{
...
...
}
void main()
{
int **arr;
arr=new int *[4];
for(int i=0;i<4;i++)
arr[i]=new int [4];
func1(arr);//компилятор нас ругает

}

И здесь пАлево

Код:

//Как неправильно, здесь мы пАлимся 
void func1(int **arr)
{
...
...
}
void main()
{
int arr[4][4];

func1(arr);//компилятор нас ругает
агтс1((int **)arr);//компилятор нас не ругает, но за это мы пАлимся еще круче:)
		// незаметно для себя :)

}

Думаю смысл понятен.

[Finch]

Все пишут код в меру своего богатого воображения. Только я не совсем уловил сути спора. Объясните хоть, о чем спорим. Может мне тоже понравится. Ох я скажу, скажу........

[nikedeforest]

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

[Dimka]

и нет языков, где можно употребить термин "Двухмерные массивы".

Не знаю... смотрю книжки по С/С++ - везде говорится о "многомерных массивах". Иные книжки авторитетов, типа Страуструпа, иные - учебники с грифом "Рекомендовано министерством образования". Похоже, отрицание многомерных массивов - это местное частное изобретение, озвученное в этой теме.

Вот у Страуструпа в разделе "B.7.3 Передача многомерных массивов" сказано, что, опускать можно лишь первую размерность (так что выше моё утверждение о последней размерности несправедливо). Оно и логично, ибо по смыслу int[][]...[] интерпретируется как массив массивов (...((int[])[])...[]) - где скобки условно обозначают порядок "приложения" размерностей.