Передача по ссылке двумерного динамического массива в функцию

Приведите, пожалуйста, пример. Нигде не могу найти.

0

Сообщение от hoggy что на плюсах не существует никаких динамических массивов

Нет массивов, память под которые выделяется в куче во время выполнения программы? Или чего нет?

Добавлено через 7 минут
Приведи мне серьёзного автора, который такое утверждает. Тебя слушать? А ты, собственно, кто? Молодец среди овец?

	Комментарий модератора
	nord_v, по хорошему прошу, ведите себя пристойно!

0

Сообщение от nord_v Приведи мне серьёзного автора, который такое утверждает.

Я уже приводил цитату из стандарта. Размер массива - константа времени компиляции.
new-expression размещает там где-то массив, но возвращает указатель на первый элемент, а не массив.


Динамический(динамически выделенный) - выделен в рантайме.
Динамический не значит расширяемый.
Динамический(расширяемый) - не существует.

1

Сообщение от nord_v Мне тебя слушать, или Прата?

нужно не просто слушать.
нужно понимать услышанное.

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

вот только деццкий садик уже позади.
пора взрослеть.

Сообщение от Croessmah Это чуть-чуть уже на страницу. Бестолку как углубится в язык, так сам дойдет

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

иногда для этого нужно попачкать страничку другую

1

0

Сообщение от nord_v И там такие массивы называют массивами, в отличие от тебя:

Ну грубо говоря это массив, но неужели непонятно что p1 в этом коде указатель, а указатель!=массив?

Сообщение от nord_v C++ 1 2 3 int n; std::cin >> n; int* p1 = new int[n];

0

Сообщение от nord_v Нет массивов, память под которые выделяется в куче во время выполнения программы?

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

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

никакого массива у вас при этом на руках нет, и никогда не было.

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

например, когда компилятор встречает в коде указатель: int* p
то он думает, что указатель содержит адрес объекта типа int

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

2

Сообщение от hoggy в самом языке не существует типа данных "динамический массив".

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

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

Чем это отличается от статического создания массива? Тоже тупо выделяется энное количество байт - непрерывный кусок сырой памяти, имя массива - указатель на начало этого блока, вот и вся история.
Известен размер? Динамически создаваемого тоже известен, только программисту недоступен через указатель. Поэтому это не массив?
Или дай своё определение массива. Оно, вообще, существует в стандарте, в языке?

Сообщение от hoggy например, когда компилятор встречает в коде указатель: int* p то он думает, что указатель содержит адрес объекта типа int а то, что там оказывается подразумевается целый массив данных - об этом знает только программист, который написал этот код.

А когда компилятор встречает delete [] p, он что думает? Или тут программист ему подсказывает?
За тебя попытаюсь дать твоё определение массива: если компилятор, встретив указатель (имя массива), знает, что это указатель на непрерывный блок памяти известного размера, то это указатель на начало именно массива (имеем массив), если встретив указатель (и нет подсказки программиста) думает, что указатель содержит адрес только одного объекта известного типа, то это не указатель на начало массива (массива не имеем). Так?

Добавлено через 10 минут

Сообщение от Croessmah new-expression размещает там где-то массив, но возвращает указатель на первый элемент, а не массив.

Croessmah, ты как-то определись - это указатель на начало массива или не массива?

Сообщение от Croessmah Я уже приводил цитату из стандарта.

Сообщение от Croessmah Ну и для new

Тут везде array, array.

0

Сообщение от nord_v Под динамическим обычно подразумевают автоматически расширяемый массив, типа вектора.

Полезно будет почитать Damian Dechev, Peter Pirkelbauer, and Bjarne Stroustrup "Lock-free Dynamically Resizable Arrays"

Сообщение от nord_v Тоже тупо выделяется энное количество байт

Сообщение от nord_v динамически создаваемый массив.

да хоть сколько, важно что всё это динамически создается.

Чем это отличается от статического создания массива?

Если Вы про

Сообщение от nord_v А когда компилятор встречает delete [] p, он что думает? Или тут программист ему подсказывает?

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

Сообщение от nord_v встретив указатель (имя массива)

Читать пока не дойдет

Сообщение от Новичок указатель!=массив

Сообщение от nord_v что это указатель на непрерывный блок памяти

ему неизвестно что это за указатель и что там по адресу. Ему известно лишь то, что это указатель, значит в нем записан адрес, для указателя имеются такие вот операции (в т.ч. "[]", "++", "--" и т.д.).
А вот когда он встречает массив, он знает его размер, потому как это массив, а не сырой указатель.

Добавлено через 4 минуты

Сообщение от nord_v Croessmah, ты как-то определись - это указатель на начало массива или не массива?

Перечитай еще раз! И еще! И еще!

Сообщение от nord_v Тут везде array, array.

потому что для людей так удобнее. А теперь внимание, если причитаться, во многой литературе используют выражение "memory block", а не "array" и это будет точнее.

Добавлено через 1 минуту
Для тебя:

0

Сообщение от Croessmah Чем это отличается от статического создания массива? Если Вы про

Я про описание hoggy.

Сообщение от Croessmah Перечитай еще раз! И еще! И еще!

Чего там перечитывать! У тебя, то массив, то не массив. Сам разберись.

	Комментарий модератора
	Третье устное предупреждение. Если и дальше продолжите вести себя столь грубо, последуют более суровые меры. Давайте будем взаимовежливы.

0

Сообщение от nord_v Croessmah, ты как-то определись - это указатель на начало массива или не массива?

Сообщение от nord_v Хрен ли там перечитывать. У тебя, то массив, то не массив. Сам разберись.

На начало "массива" можно сказать(обратите внимание на кавычки).

0

Сообщение от Croessmah Для тебя:

Знаю я это всё. Это я всё описал в определении, единственное, что там неверно, что я имя массива приравнял к указателю. Пускай будет вместо указателя адрес (именованная область памяти (имя массива) - это же адрес?).

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

Сообщение от Новичок обратите внимание на кавычки

В стандарте, который привёл Croessmah, на кавычки укажи.

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

Сообщение от Croessmah потому что для людей так удобнее.

Значит так и будем считать (мы же люди), что возвращает указатель на начало массива (без кавычек, Новичок, обратите внимание).

0

Ну писали же

Сообщение от Croessmah the new-expression yields a pointer to the initial element (if any) of the array

Сообщение от Croessmah потому что для людей так удобнее. А теперь внимание, если причитаться, во многой литературе используют выражение "memory block", а не "array" и это будет точнее.

0

Сообщение от nord_v У тебя, то массив, то не массив.

Вот тебе из википедии

Массив (в некоторых языках программирования также таблица, ряд, матрица) — тип или структура данных в виде набора компонентов (элементов массива), расположенных в памяти непосредственно друг за другом.

то бишь любой участок памяти - массив. Любой объект в языке - это массив байт.

А теперь что такое "статический тип" массив:

In a declaration T D where D has the form D1 [ constant-expression_opt ] attribute-specifier-seq_opt and the type of the identifier in the declaration T D1 is “derived-declarator-type-list T”, then the type of the identifier of D is an array type;

А почему тогда имя массива можно использовать как указатель?
А потому что разрешен неявный каст

An lvalue or rvalue of type “array of N T” or “array of unknown bound of T” can be converted to a prvalue of type “pointer to T”. The result is a pointer to the first element of the array.

Сообщение от nord_v Я про описание hoggy.

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

0

Сообщение от Croessmah Вот тебе из википедии Массив (в некоторых языках программирования также таблица, ряд, матрица) — тип или структура данных в виде набора компонентов (элементов массива), расположенных в памяти непосредственно друг за другом. то бишь любой участок памяти - массив. Любой объект в языке - это массив байт.

Сообщение от Croessmah В силу того, что кусок памяти непрерывный, чаще его называют его массивом (потому что общий термин массив таков).

Ну, вот и чудненько! Поэтому (и для удобства(моего, другим может удобнее называть это "memory block")) будем называть динамически выделенный блок памяти - массивом, а указатель, с адресом начала этого блока - указателем на начало динамически созданного массива. Три отличия от статически созданного: 1) память выделяется в куче; 2) создаётся во время работы программы, а не во время компиляции; 3) через указатель, в отличии от имени статически созданного массива, нельзя получить размер выделенного блока памяти (хотя компилятор знает этот размер, что он и демонстрирует при выполнении delete []).
Уф, на этом можно и остановиться...

0

Сообщение от nord_v 1) память выделяется в куче;

не обязательно.

Сообщение от nord_v 3) через указатель, в отличии от имени статически созданного массива, нельзя получить размер выделенного блока памяти (хотя компилятор знает этот размер, что он и демонстрирует при выполнении delete []).

законным способом - нет. Но зачастую реализации предоставляют такой функционал.

0

Сообщение от nord_v Динамически создаваемых тоже не существует?

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

вот вам пример:

я подозреваю, что вы имели ввиду совершенно не это.

аккуратнее с формулировками.
конкретизируйте свой вопрос.

динамически создаваемый - это:
1.
создаваемый времени выполнения?
2.
имеющий динамический класс хранения?
3.
размерности массива известны лишь времени выполнения?

что именно вы имеете ввиду?

Сообщение от nord_v Чем это отличается от статического создания массива? Тоже тупо выделяется энное количество байт - непрерывный кусок сырой памяти, имя массива - указатель на начало этого блока, вот и вся история.

это - не вся история.
это - только начало истории.

имя массива внезапно - имя массива, а не имя указателя.
вапще указатели с массивами только новобранцы путают.
они пока ещё не осознали профит от использования массивов.

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

грубо говоря, представьте себе,
что массив "помнит" свои размерности.
эту информацию можно извлекать времени компиляции,
и использовать.

например, гарантировать безопасность выхода за пределы диапазона массива.

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

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

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

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

и реализовывать таким образом различные сценарии бизнес-логики.

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

короче - полноценный механизм.

Сообщение от nord_v А когда компилятор встречает delete [] p, он что думает? Или тут программист ему подсказывает?

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

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

компилятор не телепат,
он понятия не имеет,
что там под этим указателем.

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

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

delete [] - это приказ программиста интерпретировать данные по указателю,
как блок памяти, выделенный при помощи new[]

Сообщение от nord_v Так?

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

даже если его тыкнуть мордой: delete[] p
то он все равно ничего не знает о том, что там за данные,
и какие там размеры у объектов.

для компилятора delete[] p это примерно тоже самое, что и free(p)

а что там внутри этой функции - ему до фонаря,
что там написано, то он и сделает.

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

самая популярная реализация следующая:

выражение:
выделяет блок с хвостиком:

[хвостик][some 0][some 1]

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

соответственно, delete[] p
берет адрес p
и отматывается от него назад на размер хвоста.
и получает информацию из этого хвостика.
узнает о количестве элементов и тд.

получив информацию о блоке данных,
запрашивает рантайм с++ об уничтожении блока.

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

и если вы скормите delete[] какой нибудь левый указатель,
то она его схавает.
точно так же отмотается до хвоста, прочитает полный бред,
и сожрет его.
а потом ось грохнет все приложение со словами:
"вы че там, с ума посходили?"

Сообщение от Croessmah Этим типом может быть массив, а может и не быть.

вот здесь нужно уточнение.
new-expression в этом месте сахарком посыплен.
туда можно реально тип данных вкрячить,
а можно вкрячить "имитацию" с размерностью известной лишь времени выполнения.
(только для одной размерности).

во втором случае оно выглядит как массив, но массивом уже не является.

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

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

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

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

7

0

Спасибо hoggy, и Croessmah, нужно обдумать всё это. Я уже было подумал, что вернулся в исходную точку, но hoggy, последним постом (особенно насчёт работы delete []), посеял зерно сомнения.

0

nord_v, всё дело именно в терминах.
Например, те же переводчики переводят operator и statement одинаково - оператор, в результате новички просто не понимают различий, отсюда всякие косяки в синтаксисе, непонимание что к чему относится и как разбирается.
Также stream и thread переводятся одинаково - поток. В результате почти каждое приложение можно назвать многопоточным.
Тоже и с путаницей между оператором new и new-выражением.
Такая же беда и со статическими переменными (имеющими статическое время хранения и переменными, созданными не в динамике).
И, как видите, с массивами тоже.

1

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

1) Массив ФРСВВК (массив фиксированных размеров создаваемый во время компиляции)
2) Статический массив ФРСВВК (массив ФРСВВК с ключевым словом static)
==========================
3) Массив ФРСВВВ (массив фиксированных размеров создаваемый во время выполнения)
4) Статический массив ФРСВВВ
==========================
5) Массив ИРВВ (массив изменяющихся размеров во время выполнения, он же динамический, он же расширяемый). В С++ не существует, но есть готовые реализации такого функционала в стандартной библиотеке... (опять же тут допущения, ведь это псевдо ИРВВ)
==========================
Такое разделение массивов на группы. Легче бы шли объяснения.
При этом то, что начинается здесь с 3 вида, оно уже не массив внутри ПК, но зато массив в головах программиста.

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

Любой многомерный массив - это массив массивов, в конечнем счете в конечном массиве всегда массив ФР(фиксированных размеров).
В теории получается, что Многомерный массив ИРВВ - это массив, в который добавляется/из которого урезается одна или несколько размерностей. На самом деле оно реализуется по тем же принципам, по которым создается массив "ИРВВ". А то, что оно не подано на блюдечке, наверное хорошо, потому что для таких вещей уже идут структуры struct. Но можно написать свой велосипед. Ведь С++ расширяемый язык. И будет псевдорасширяемый многомерный массив.
==========================

0