Правильная расшифровка int (*a)[2] = new int[n][2];

Какой вариант однозначно правильный?

Изначально правильный вариант это std::vector, а не эта стархолюдина, которую даже не понятно как читать. Хватит уже тащить убогие сишные замашки в c++.

https://cdecl.org/

Если сам не допираешь, спроси у чатгпт. Он уже очень хорошо такие вопросы разъясняет.

https://cdecl.org/

int (*a)[2] - declare a as pointer to array 2 of int

Что бы это значило? Определить a как указатель на массив длинной 2 из int? Определить a как указатель на 2 массива из int?

new int[n][2] - syntax error

В общем, яснее не стало.

Указатель на массив из 2 элементов типа int.

Указатель на массив из 2 элементов типа int.

Хорошо, теперь рассмотрим выражение new int[n][2]. Действуем поэтапно.

new int[n] - выделить динамическую память для массива из n элементов.

new int[n][2] - выделить динамическую память для двух массивов из n элементов.

Правильно или нет?

Хорошо, теперь рассмотрим выражение new int[n][2]. Действуем поэтапно.

new int[n] - выделить динамическую память для массива из n элементов.

Ты пропустил этап «почитать учебник»

Нет.

это не плюсы, new не нужен.

Это плюсы, смотри теги темы.

3. Исправить на нормальный код, автору сломать пальцы.

тогда

class pair;

pair* array_of_pairs = new pair[n];

Кмк тут лучше будет std::array

Вопрос не в том что лучше/хуже. Вопрос в том, как понимать запись.

void main() 
{
	size_t n = 42;
	int(*a)[2] = new int[n][2];

	a[35][1] = 512;
}

Похоже, что указатель на n массивoв (или массив из n массивов) из двух интов

В общем, более правильное описание будет такое:

int (*a)[2] = new int[n][2];

Создается переменная-указатель на массив из 2-х элементов int и она указывает на нуливой элемент массива длинной n. Каждый элемент массива является указателем на соответствующий массив из 2-х элементов типа int.

Каждый элемент массива является указателем на соответствующий массив из 2-х элементов типа int.

Нет, не является

а вы говорите - Лев Толстой.

для начала предлагаю распарсить

Жили-были кот, дрозд да петушок — золотой гребешок

а там как пойдет.

Нет, не является

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

cdecl.org: declare a as pointer to array 2 of int

int (*a)[2] – объявление a как указателя на массив из двух int.

В С++ типом а будет не (int **), а int (*)[2].

new int[n][2] – создание массива из n элементов, каждый элемент которого указывает на массив из двух элементов типа int (которые тоже создаются).

В С++ типом а будет не (int **), а int (*)[3].

Размерность, используемая в типе, должна быть фиксированной? И через этот тип нельзя обратиться к массиву длинной 2 а не 3?

Можно сделать приведение типов. Но твой пример кода действительно плохой, т.к. сам сопоставь что ты объявляешь и что присваиваешь, есть некоторое несоответствие…

Но твой пример кода действительно плохой, т.к. сам сопоставь что ты объявляешь и что присваиваешь, есть некоторое несоответствие…

Не вижу разницы, объясни.

Сам пример взят вот отсюда: https://metanit.com/cpp/tutorial/4.12.php

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

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

Если честно, то я не очень понимаю область использования двумерных массивов вида new a[m][n], т.к. это, по-сути, матрица но созданная хз пойми как. Лучше выделить память m*n и самостоятельно разметить ее (если нужно). А если это массив массивов, где длины могут меняться независимо, т.е. точно не матрица, то лучше использовать std::vector и std::array и пр.

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

Дык когда работаешь с указателями, какой, к черту, контроль границ массива? Да и без указателей тоже - выходи за границы, никто не отследит если сам следить не будешь. (Речь в данном случае о размерности n).

Если честно, то я не очень понимаю область использования двумерных массивов вида new a[m][n], т.к. это, по-сути, матрица но созданная хз пойми как. Лучше выделить память m*n и самостоятельно разметить ее (если нужно).

Я тоже не понимаю зачем так извращенно сделано. В i386 в машкоде даже есть готовые команды для работы с двумерными массивами (доступ к памяти по X + xSize * Y), но они не могут применяться если делать двумерный массив в стандартном C/C++ стиле. Для 3-х измерений и выше тоже непонятно зачем при доступе к элементу вместо математических вычислений смещения ячейки «на месте», нужно делать цепочку чтений указателей из памяти. Учитывая, что память под многомерный массив выделяется одним блоком.

кто-то не читал главу учебника про n-мерные(двумерные) массивы. Объявление указателя такое. тип_данных (*lbl)[размерность] Если делать указатель на указатель, то компилятор не сможет узнать вторую размерность. Вообще, по-умному здесь надо делать одноразмерный массив и вручную указывать границы. Потом будет меньше гемора.

Дык когда работаешь с указателями, какой, к черту, контроль границ массива? Да и без указателей тоже - выходи за границы, никто не отследит если сам следить не будешь. (Речь в данном случае о размерности n).

Ну тогда да, тогда без разницы.

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

А это точно так? Я вот не знаю как там в стандарте на этот счет написано. И можно ли потом delete[] a[3] и a[3] = new int[20] сделать?

кто-то не читал главу учебника про n-мерные(двумерные) массивы. Объявление указателя такое. тип_данных (*lbl)[размерность]

Учебники разные бывают, ссылку я уже привел. Ты хочешь сказать, что в скобках указывается не размер массива, а размерность? То есть определение int (*ourArray)[5] указывает на пятимерный массив а не на массив длинной 5?

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

Но это же не помешает обращаться к элементу как ourArray[x][y]. А контроля границ массива в C/C++ и так нет.

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

Но за каким-то хреном авторы языка же сделали синтаксис такой как в топике.

Но за каким-то хреном авторы языка же сделали синтаксис такой как в топике.

Синтаксис вполне логичный.

int a[2] – массив из 2х элементов.

int* a[2] – массив указателей на int из двух элементов.

int (*a)[2] – указатель на массив из двух элементов.

(*a) в объявлении означает, что а это будет указатель, т.е. как бы объявляешь *a, которое есть понятно что, а пользуешься только a.

А это точно так? Я вот не знаю как там в стандарте на этот счет написано. И можно ли потом delete[] a[3] и a[3] = new int[20] сделать?

Я к тому, что вместо циклического выделения (что выделяет память фрагментами):

int** numbers{new int*[rows]{}};
for (unsigned i{}; i < rows; i++)
{
   numbers[i] = new int[columns]{};
}

int (*a)[2] = new int[n][2];

Ну вот то-то и оно. Что это, упрощенное написание циклической инициализации или создание матрицы с вектором указателей на строки? Надо стандарт смотреть. И то и другое имеет смысл.

Как бы объяснить. объявление int a[2][5] выделит память под 2*5 int’ов и область под 2 указателя. Обращение a[0] и a[1] - это указатели. Объявление int (a)[5] создаст область памяти 15 и область памяти под указатель на эту выделенную область.

Поправка: Объявление int(*a)[5] Markdown звездочки сжирает. Там тоже не 15,a 1*5 и 2*5

Идиократия на марше

Никаких двух указателей оно не выделит. int[2][5] это 10 int-ов и ничего кроме них. [] это синтаксический сахар для двумерной адресации, на суть алгоритма не влияет.

а можешь ссылку на параграф в стандарте дать?

new int[n][m] выделяет блок памяти размером sizeof(int)*m*n байт и возвращает указатель на него, скастованный в тип int(*)[m], который записывается в переменную a. Блок памяти логически (в исходнике) представлен как n строк по m элементов каждая, расположенных одна за другой непрерывно в памяти.

Тип int(*)[m] означает вот что:

a - указатель на начало блока памяти

a[0] - всё тот же указатель на начало блока памяти, но скастованный в int*

a[j] - указатель на начало j-ой строчки (она начинается через j*m*sizeof(int) байт от начала), скастованный в int*

a[j][i] - значение элемента, начинающегося от начала блока через такое количество байт: (j*m+i)*sizeof(int)

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

Не могу, я его не читал.

Я пытался объяснить объяление int (*a)[5] через аналогию, чтобы было понятно. Но тут Вы правы. Коряво вышло.

new int[n][m] выделяет блок памяти размером sizeof(int)*m*n байт и возвращает указатель на него, скастованный в тип int(*)[m], который записывается в переменную a. Блок памяти логически (в исходнике) представлен как n строк по m элементов каждая, расположенных одна за другой непрерывно в памяти.

Определение int(*a)[m] означает вот что:

a - указатель на начало блока памяти

a[ 0 ] - всё тот же указатель на начало блока памяти, но скастованный в int*

a[ j ] - указатель на начало j-ой строчки (она начинается через j*m*sizeof(int) байт от начала), скастованный в int*

a[ j ][ i ] - значение элемента, начинающегося от начала блока через такое количество байт: (j*m+i)*sizeof(int)

Другими словами, определение int (*a)[m] дает возможность работать с массивом, созданным через new int[n][m]. Причем массив создается планарным, просто как n x m элементов int без этих ваших указателей на подмассивы.

Правильно?

* * *

Получается, что вот это утверждение неверно:

int (*a)[2] = new int[n][2];

Создается переменная-указатель на массив из 2-х элементов int и она указывает на нуливой элемент массива длинной n. Каждый элемент массива является указателем на соответствующий массив из 2-х элементов типа int.

Оно было бы верно, если бы тип был int**. Но тогда определение с этим типом не скомпилилось бы: int** a = new int[n][2].

Правильно?

Другими словами, определение int (*a)[m] дает возможность работать с массивом, созданным через new int[n][m]. Причем массив создается планарным, просто как n x m элементов int без этих ваших указателей на подмассивы.

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

Можешь даже скастовать его в int* и пользоваться этими n*m элементов вручную одномерно. Или наоборот - сделать new int[n*m] и скастовать в int(*)[m] и пользоваться двумерно.

Получается, что вот это утверждение неверно:

Я не очень понял что там имелось ввиду. Но int** и int[][] - это разные типы, да. Первый и правда можно использовать как массив указателей на вложенные массивы, но выделить такую структуру за один раз невозможно - надо выделять каждый вложенный отдельным new.

Ого. Куча народу не может договориться об одной строке.

Что-то это да характеризует.

https://en.cppreference.com/w/cpp/language/new

• a Бююююкафка Ааааааааа
• *a Станооовица пааачтальёёёнам
• (*a) И тут она натужилааась, зимой в тулупчик сууунулааась
• (*a)[2] И сильно напряглась, чтоб получилось двась

И вот она красивая, в тулупчике идёт
И в сумочках двух синеньких
Нам два письма несёт
Пам-пам пара-рам па-ра-ра-рам
Пам-пам пара-рам пам-free…

Обращение a[0] и a[1] - это указатели.

Нет

int **a; и int a[10][10]; это не только разные типы, но и хранятся они по разному, в первом случае действительно указатели на указатели, во втором плоский массив на 100 элементов.

Просто жависты пришли в тред о С++, там все по другому.

Ну и да и нет

• a[0] это сокращение к a + ( 0 * sizeof(a))
• a[1] это сокращение к a + ( 1 * sizeof(a))

Да – это потому что итог операции == смещённый указатель
Нет – это потому что скобочки скрывают операцию сложения (сахар)

Ну в смысле операция получения смещения по указателю vs смещённый указатель. Тут как воспринимать. А на этапе объявления это вообще про другое…

во втором плоский массив на 100 элементов.

Нет, это был бы int a[100]

int a[10][10] это 10 массивов по 10 int.