Здравствуйте, kiamor, Вы писали:

VD>>Чувствую что ты не понимашь о чем говоришь.

K>Тон смени.

Не хами. Тон нормальный. То что с тобой не согласны еще не является оскорблением.

K> Считаю ты невнимательно отнёсся к первоначальному сообщению м моему ответу.

Ну, иж извини каков ответ таково и отношение.

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

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

K>Позволю себе обратить Ваше, сэ-э-э-р, внимание на ряд похоже не очевидных для Вас фактов:

K> — речь идёт не о динамических массивах

Да? Ты Яву то видел? Массивы то там только одного типа. Изменять арзмер в них нельзя, но на то они и вложенные, чтобы можно было заменять один вложенный массив другим.

K> — я вовсе не претендую на абсолютную инстанцию

Ну, хоть это хорошо.

K> (так что не надо пытаться меня прилюдно распять за базар отвечаю )

С "базарами" это вообще не на этот сайт. Тут гопоту не любят. Раз пять (или сколько будет угодно) тебя тут никто не хочет. Просто ты сделл утверждение, я тебе возразил. Учись плюрализму.

Здравствуйте, Кодт, Вы писали:

VD>>Что до реализации, то массивы массивов могут быть реализованы только одним способом. Мномерные же разными, но эффективная реализация именно единым блоком памяти. Так что слова Quintanar неверны только с очень теоритической точки зрения. На практике же так оно и есть.

К>Можно сделать jagged array в цельном блоке памяти — правда, реализация будет мучительной донельзя, с кучей ограничений и т.д.

Это уже будет не вложенные массивы. Как ты заменишь один подмассив более большим?

К>Или когда нужно выжать все капли — программирование для микроконтроллеров.

Для этого и массивы не нужны. Указателей достаточно.

К>Но разумеется, эффективная реализация — у jagged array это массив указателей на массивы, а у матрицы — линеаризация.

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

Здравствуйте, VladD2, Вы писали:

К>>Можно сделать jagged array в цельном блоке памяти — правда, реализация будет мучительной донельзя, с кучей ограничений и т.д.

VD>Это уже будет не вложенные массивы. Как ты заменишь один подмассив более большим?

А это вообще отдельный разговор — как менять размер массива на ходу. Он и для матрицы нетривиально решается, а тем более для рваного края.
Тупое решение — взять да подвинуть все данные за концом этого подмассива. Более хитрое — похимичить с индексами и передвинуть не все данные...
Наконец, сделать собственный аллокатор. (Придём к тому, от чего бегали; только вместо общеупотребимых указателей можем использовать смещения).

Влад, я согласен: все реализации, кроме классической — либо офигенно неэффективны, либо очень ограничены.
Но это не значит, что их не бывает. Вот и всё.

Здравствуйте, Кодт, Вы писали:

К>А это вообще отдельный разговор — как менять размер массива на ходу.

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

К> Он и для матрицы нетривиально решается, а тем более для рваного края.

Ты явно не понял что я сказал.

К>Тупое решение — взять да подвинуть все данные за концом этого подмассива.

Это очень тупое решение. Оно не учитывает того, что на подмассивы могут быть отдельные ссылки.

К> Более хитрое — похимичить с индексами и передвинуть не все данные...

Аналогично.

К>Наконец, сделать собственный аллокатор. (Придём к тому, от чего бегали; только вместо общеупотребимых указателей можем использовать смещения).

Это тут вообще не причем. Проблема концептуальна.

К>Влад, я согласен: все реализации, кроме классической — либо офигенно неэффективны, либо очень ограничены.
К>Но это не значит, что их не бывает. Вот и всё.

Нет. Тут дело в другом. Вложенные массивы это совершенно другая (идеологически другая) сущность нежели матрица. Вот простенький пример:

byte[][] jaggedArray = new byte[3][] { new byte[] { 1, 2 }, null, new byte[] { 4, 5, 6 } };
// ...
byte[] array0 = jaggedArray[0];
jaggedArray[0] = new byte[20];
jaggedArray[1] = jaggedArray[2];

array0[1] = jaggedArray[1][2] = 123;

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

кто тебе сказал что речь идёт о массивах конкретно и только явы?

при чём здесь гопота? ты сообщение-то прочёл? или слова знакомые искал?

Здравствуйте, Кодт, Вы писали:

К>Если такое (***) возможно, это значит, что в Обероне — массивы массивов. А если невозможно — то чисто многомерные массивы.
(***) возможно, но вот такое невозможно

PROCEDURE Impossible(VAR a: ARRAY OF ARRAY OF REAL;b:ARRAY OF REAL);
BEGIN
  a[0]:=b;
END Impossible;

Здравствуйте, ansi, Вы писали:

A>В чем отличие массива массивов от многомерного массива и почему многомерный массив вроде бы как лучше. Сколько ни писал на Java и на C++, разницы так и не заметил

Вот, что такое реальные массивы:

>  a:!9
>  a
0 1 2 3 4 5 6 7 8
>  a: 3 3 #a 
>  a
(0 1 2
 3 4 5
 6 7 8)
>  a[0]
0 1 2
>  a[;0]
0 3 6
>  a[1;2 0 1]
5 3 4

Здравствуйте, Quintanar, Вы писали:

Q>Здравствуйте, Сергей Губанов, Вы писали:

СГ>>Многомерный массив и массив массивов это в точности одно и тоже — один большой кусок памяти:
СГ>>

СГ>>ARRAY M, N OF ... = (* сокращенное обозначение для *) = ARRAY M OF ARRAY N OF ...
СГ>>

СГ>>А что касается случая когда память фрагментирована — так это массив указателей на массивы.
СГ>>

СГ>>ARRAY M OF POINTER TO ARRAY N OF ...
СГ>>

Q>Да я вообще не знаю, что такое указатели. С такими древними сущностями работают только низкоуровневые языки.

Это Вы перепутали два разных понятия указатель и адрес. Низкоуровневые языки как раз работают с адресами, в то время как высокоуровневые языки — с указателями. Указатели могут управляться сборщиком мусора, в то время как адреса — не могут. В частности, в Oberon-ах, Java, C# используются как раз указатели, но не адреса. Что касается языков Си/Си++, то в них адрес=указатель, поэтому к какому классу (низкоуровневых или высокоуровневых) их отнести сказать сложно.

Здравствуйте, VladD2, Вы писали:

VD>Массив массивов — это массив ссылок на массивы определенного типа (в том числе и опять же массивов массивов).


Массив — это value-type, поэтому массив массивов — это одно, а массив указателей на массивы — совсем другое.

Здравствуйте, VladD2, Вы писали:

VD>Нет. Тут дело в другом. Вложенные массивы это совершенно другая (идеологически другая) сущность нежели матрица. Вот простенький пример:
VD>

VD>byte[][] jaggedArray = new byte[3][] { new byte[] { 1, 2 }, null, new byte[] { 4, 5, 6 } };
VD>

В C# массивы есть классы, то есть reference-type, а значит в C# "вложенные массивы" есть массив ссылок на массивы. А на самом деле, массивы должны быть value-type, и таких настоящих массивов нет ни в C# ни в .NET ни в Java (зато они есть в Оберонах, Модулах, и даже в древнем Паскале, правда в Паскале они в ограниченном виде).

Здравствуйте, Сергей Губанов, Вы писали:

СГ>Здравствуйте, VladD2, Вы писали:

VD>>Нет. Тут дело в другом. Вложенные массивы это совершенно другая (идеологически другая) сущность нежели матрица. Вот простенький пример:
VD>>

VD>>byte[][] jaggedArray = new byte[3][] { new byte[] { 1, 2 }, null, new byte[] { 4, 5, 6 } };
VD>>

СГ>В C# массивы есть классы, то есть reference-type, а значит в C# "вложенные массивы" есть массив ссылок на массивы. А на самом деле, массивы должны быть value-type, и таких настоящих массивов нет ни в C# ни в .NET ни в Java (зато они есть в Оберонах, Модулах, и даже в древнем Паскале, правда в Паскале они в ограниченном виде).

Имхо, это слишком категоричное и субъективное утверждение.

Здравствуйте, VladD2, Вы писали:

<>

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

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

Здравствуйте, VladD2, Вы писали:

VD>Массив массивов — это массив ссылок на массивы определенного типа (в том числе и опять же массивов массивов).

А что тогда "массив ссылок на массивы"?

Здравствуйте, eao197, Вы писали:

СГ>>...массивы должны быть value-type...

Добавка: сами масивы value-type, а тип POINTER TO ARRAY — естественно, reference-type

E>Имхо, это слишком категоричное и субъективное утверждение.

А я его могу еще более "усугубить". В языке программирования вообще все-все-все что только можно должно быть value-type. Тогда на таком языке можно будет писать программы используя динамическое распределение памяти (new) только тогда когда это действительно необходимо, а не "на каждый чих". Меньше нагрузка на сборщик мусора — быстрее работать будет.

Здравствуйте, Сергей Губанов, Вы писали:

СГ>Здравствуйте, eao197, Вы писали:

СГ>>>...массивы должны быть value-type...

СГ>Добавка: сами масивы value-type, а тип POINTER TO ARRAY — естественно, reference-type

E>>Имхо, это слишком категоричное и субъективное утверждение.

СГ>А я его могу еще более "усугубить". В языке программирования вообще все-все-все что только можно должно быть value-type. Тогда на таком языке можно будет писать программы используя динамическое распределение памяти (new) только тогда когда это действительно необходимо, а не "на каждый чих". Меньше нагрузка на сборщик мусора — быстрее работать будет.

Имхо, это еще одно слишком категоричное и субъективное утверждение

Здравствуйте, Сергей Губанов, Вы писали:

СГ>Это Вы перепутали два разных понятия указатель и адрес. Низкоуровневые языки как раз работают с адресами, в то время как высокоуровневые языки — с указателями. Указатели могут управляться сборщиком мусора, в то время как адреса — не могут. В частности, в Oberon-ах, Java, C# используются как раз указатели, но не адреса. Что касается языков Си/Си++, то в них адрес=указатель, поэтому к какому классу (низкоуровневых или высокоуровневых) их отнести сказать сложно.
В других высокоуровневых языках это называется указатель и ссылка.

С уважением, Gleb.

Здравствуйте, GlebZ, Вы писали:

GZ>В других высокоуровневых языках это называется указатель и ссылка.

Да, вот такая вот путаница у нас есть.

Есть три разных понятия
1) адрес,
2) указатель [в отличие от адреса может управляться GC],
3) ссылка.

Таблица соответствия этих понятий в разных языках:

            +---------------+---------------+---------------+---------------+
            |    Обероны    |      C/C++    |      С#       |      Java     |
+-----------+---------------+---------------+---------------+---------------+
|           |               |               |    есть       |               |
|  адрес    | INTEGER       |               |  только в     |     нету      |
|           |               |               |   unsafe      |               |
+-----------+---------------+     Foo*      +---------------+---------------+
|           |               |               |               |               |
| указатель | POINTER TO    |               | class, byte[] |     class     |
|           |               |               |               |               | 
+-----------+---------------+---------------+---------------+---------------+
|           |               |               |               |               |
|  ссылка   | VAR, IN, OUT  |       &       |  ref, out     |     нету      | 
|           |               |               |               |               |
+-----------+---------------+---------------+---------------+---------------+

Адрес в Си/Си++/Си#, по ошибке, называют указателем. Указатель в Си/Си++ тоже называют указателем не делая различия между адресом и указателем, а в Си# указатель называют ссылкой, видимо по тому что слово указатель уже занято для обозначения адреса. Ссылку в Си/Си++ называют ссылкой — молодцы, а вот в C# хоть ссылку и тоже называют ссылкой, но они еще и указатель тоже ссылкой называют — слов не хватило (указатель и ссылку обозвали одним словом ссылка).

Здравствуйте, Трурль, Вы писали:

К>>Если такое (***) возможно, это значит, что в Обероне — массивы массивов. А если невозможно — то чисто многомерные массивы.
Т>(***) возможно, но вот такое невозможно

Т>

Т>PROCEDURE Impossible(VAR a: ARRAY OF ARRAY OF REAL;b:ARRAY OF REAL);
Т>BEGIN
Т>  a[0]:=b;
Т>END Impossible;
Т>

Значит это просто кривой синтаксис. А по сути это обычные матрицы.

Здравствуйте, kiamor, Вы писали:

K>кто тебе сказал что речь идёт о массивах конкретно и только явы?

\Понятно. То есть ты даже не удосужился прочесть вопрос в теме. Ладно, я его процитирую:

В чем отличие массива массивов от многомерного массива и почему многомерный массив вроде бы как лучше. Сколько ни писал на Java и на C++, разницы так и не заметил

K>при чём здесь гопота?

Вот это:

за базар отвечаю

навивает.

K>ты сообщение-то прочёл? или слова знакомые искал?

Этот вопрос я хотел бы переодресовать тебе.

Здравствуйте, Сергей Губанов, Вы писали:

СГ>В C# массивы есть классы, то есть reference-type, а значит в C# "вложенные массивы" есть массив ссылок на массивы. А на самом деле, массивы должны быть value-type, и таких настоящих массивов нет ни в C# ни в .NET ни в Java (зато они есть в Оберонах, Модулах, и даже в древнем Паскале, правда в Паскале они в ограниченном виде).

На самом деле никто никому ничего не должен. Вложенные массивы (nested array) и уж темболеее зубчатые массивы (jagged array) — это термины из Явы и Шарпа. Собственно вопрос в теме о них и был.

А твои Обероны и Модулы — это просто манально устаревшие эксперементальные языки.