Путаница в отношении указателей и многомерных массивов

Если возможно следующее:

MyFunction(int *array, int size)
{
    for(int i=0 ; i<size ; i++)
    {
        printf("%d", array[i]);
    }
}

main()
{
    int array[6] = {0, 1, 2, 3, 4, 5};
    MyFunction(array, 6);
}

Почему следующее не?

MyFunction(int **array, int row, int col)
{
    for(int i=0 ; i<row ; i++)
    {
        for(int j=0 ; j<col ; j++)
        {
            printf("%d", array[i][j]);
        }
    }
}

main()
{
    int array[3][3] = {0, 1, 2, 3, 4, 5, 6, 7, 8};
    MyFunction(array, 3, 3);
}

Ответ 1

Во-первых, некоторый стандартный язык:

6.3.2.1 Lvalues, массивы и обозначения функций
...
3 За исключением случаев, когда это операнд оператора sizeof или унарный оператор & или строковый литерал, используемый для инициализации массива, выражение, которое имеет тип "массив типа", преобразуется в выражение с типом "указатель на тип", который указывает на начальный элемент объекта массива и не является значением lvalue. Если объект массива имеет класс хранения регистров, поведение undefined.

Учитывая объявление

int myarray[3][3];

тип myarray - это "3-элементный массив из 3-элементного массива int". Следуя приведенному выше правилу, когда вы пишете

MyFunction(myarray, 3, 3);

выражение myarray имеет свой тип, неявно преобразованный ( "распад" ) из "3-элементного массива из 3-элементного массива int" в "указатель на 3-элементный массив int" или int (*)[3].

Таким образом, ваш прототип функции должен быть

int MyFunction(int (*array)[3], int row, int col)

Обратите внимание, что int **array не совпадает с int (*array)[3]; арифметика указателя будет отличаться, поэтому ваши индексы не будут указывать на нужные места. Помните, что индексирование массива определяется в терминах арифметики указателя: a[i] == *(a+i), a[i][j] == *(*(a + i) + j). a+i даст другое значение в зависимости от того, является ли a int ** или int (*)[N].

В этом конкретном примере предполагается, что вы всегда передаете массив элементов Nx3 из int; не очень гибкий, если вы хотите иметь дело с любым размером NxM. Один из способов обойти это - это явно передать адрес первого элемента в массиве, поэтому вы просто передаете простой указатель, а затем вручную вычислите правильное смещение:

void MyFunction(int *arr, int row, int col)
{
  int i, j;
  for (i = 0; i < row; i++)
     for (j = 0; j < col; j++)
       printf("%d", a[i*col+j]);
}

int main(void)
{
  int myarray[3][3] = {{1,2,3},{4,5,6},{7,8,9}};
  ...
  MyFunction(&myarray[0][0], 3, 3);

Поскольку мы передаем простой указатель на int, мы не можем использовать двойной индекс в MyFunc; результат arr[i] является целым числом, а не указателем, поэтому мы должны вычислить полное смещение в массив в одной операции индекса. Обратите внимание, что этот трюк будет работать только для действительно многомерных массивов.

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

void AnotherFunc(int **arr, int row, int col)
{
  int i, j;
  for (i = 0; i < row; i++)
    for (j = 0; j < col; j++)
      printf("%d", arr[i][j]);
}

int main(void)
{
  int d0[3] = {1, 2, 3};
  int d1[3] = {4, 5, 6};
  int d2[3] = {7, 8, 9};

  int *a[3] = {d0, d1, d2};

  AnotherFunc(a, 3, 3);
  ...
}

Следуя приведенному выше правилу, когда в инициализаторе для a появляются выражения d0, d1 и d2, их типы все преобразуются из "3-элементного массива int" в "указатель на int". Аналогично, когда выражение a появляется при вызове AnotherFunc, его тип преобразуется из "3-элементного массива указателя в int" в "указатель на указатель на int".

Обратите внимание, что в AnotherFunc мы индексируем обе измерения вместо вычисления смещения, как это было в MyFunc. Это потому, что a - это массив значений указателя. Выражение arr[i] получает значение i-го значения указателя из местоположения arr; мы затем находим j'th целочисленное значение, смещенное от этого значения указателя.

Следующая таблица может помочь - она отображает типы различных выражений массива и их распад на основе их объявлений (T (*)[N] - тип указателя, а не тип массива, поэтому он не распадается):

Declaration            Expression            Type            Implicitly Converted (Decays) to
-----------            ----------            ----            --------------------------------
     T a[N]                     a            T [N]           T *
                               &a            T (*)[N]
                               *a            T
                             a[i]            T

  T a[M][N]                     a            T [M][N]        T (*)[N]
                               &a            T (*)[M][N] 
                               *a            T [N]           T *
                             a[i]            T [N]           T *
                            &a[i]            T (*)[N] 
                            *a[i]            T
                          a[i][j]            T

T a[L][M][N]                    a            T [L][M][N]     T (*)[M][N]
                               &a            T (*)[L][M][N]
                               *a            T [M][N]        T (*)[N]
                             a[i]            T [M][N]        T (*)[N]
                            &a[i]            T (*)[M][N]
                            *a[i]            T [N]           T *
                          a[i][j]            T [N]           T *
                         &a[i][j]            T (*)[N]
                         *a[i][j]            T 
                       a[i][j][k]            T

Образец для многомерных массивов должен быть ясным.

Ответ 2

Изменить: Здесь моя попытка ответить на более точный ответ в соответствии с запросом и на основе вашего нового примера кода:

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

В первом примере int array[6] представляет собой массив из 6 элементов int. Передача array передает указатель на первый элемент, который является int, поэтому тип параметра int *, который может быть эквивалентно записан как int [].

В вашем втором примере int array[3][3] представляет собой массив из трех строк (элементов), каждый из которых содержит 3 int s. Передача array передает указатель на первый элемент, который представляет собой массив из 3 int s. Следовательно, тип int (*)[3] - указатель на массив из 3 элементов, который может быть эквивалентно записан как int [][3].

Надеюсь, теперь вы видите разницу. Когда вы передаете int **, это на самом деле указатель на массив int * и NOT указатель на 2D-массив.

Пример для фактического int ** будет примерно таким:

int a[3] = { 1, 2, 3 };
int b[3] = { 4, 5, 6 };
int c[3] = { 7, 8, 9 };
int *array[3] = { a, b, c };

Здесь array - массив из 3 int * s, и передача этого в качестве аргумента приведет к int **.

Оригинальный ответ:

Ваш первый пример - не 2D-массив, хотя он используется аналогичным образом. Там вы создаете ROWS число указателей char *, каждый из которых указывает на другой массив символов COLS. Здесь есть два уровня косвенности.

Второй и третий примеры представляют собой 2D-массивы, где память для всех символов ROWS * COLS является смежной. Здесь существует только один уровень косвенности. Указатель на 2D-массив не char **, а char (*)[COLS], поэтому вы можете сделать:

char (*p)[SIZE] = arr;
// use p like arr, eg. p[1][2]

Ответ 3

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

Ответ 4

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

Кроме того, у этого есть хорошая информация: http://c-faq.com/aryptr/index.html

Ответ 5

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

Второй пример не работает, потому что int[3][3] вырождается до int (*)[3], а не двойной указатель int **. Это так, потому что 2D-массивы смежны в памяти, и без этой информации компилятор не знал, как получить доступ к элементам, находящимся за первой строкой. Рассмотрим простую сетку чисел:

1  2  6 
0  7  9

Если бы мы сохраняли эти числа в массиве int nums[6], как бы мы индексировали в массив для доступа к элементу 7? По 1 * 3 + 1, конечно, или, вообще говоря, row * num-columns + column. Чтобы получить доступ к любому элементу за первой строкой, вам нужно знать, сколько столбцов имеет сетка.

Когда вы сохраняете числа как nums[2][3], компилятор использует точно такую же арифметику row * num-columns + column, как и вручную, с массивом 1D, он просто скрыт от программиста. Поэтому вам необходимо передать количество столбцов при передаче 2D-массива, чтобы компилятор мог выполнить эту арифметику.

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

Ответ 6

Возможно, мы сможем ожидать более "точного" вопроса, если вы хотите получить более точный ответ. У вашей идеи две проблемы:

2D-массив int A[3][3] при использовании в выражении распадается на адрес его первого элемента таким образом, чтобы указатель типа int (*)[3]. Чтобы передать массив, вы должны использовать &A[0][0], чтобы получить указатель на первый "внутренний" элемент.
внутри вашей функции операция A[i][j] не может быть выполнено с тех пор ваш компилятор не имеет информации о длина строки, там.

Ответ 7

В этом коде есть две основные проблемы.

MyFunction(int **array, int row, int col);

Во-первых, используется int **array неправильный тип. Это указатель на указатель, а

int array[3][3] = {0, 1, 2, 3, 4, 5, 6, 7, 8};

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

int *A[99];

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

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

int array[3][3] = {0, 1, 2, 3, 4, 5, 6, 7, 8};
printf("%p %p %p\n", array, array[0], &(array[0][0]) );

Вы должны получить тот же адрес, который был напечатан 3 раза, потому что все они относятся к одному и тому же адресу, но их типы не совпадают. Тип данных последних двух аналогичен и совместим для многих целей, поскольку array[0] будет рассматриваться как указатель на первый элемент первой строки array, и эта строка является массивом сама по себе.

Если вы скажете:

int **A;

Вы говорите, что есть указатель на указатель на int. Хотя A[2][4] является допустимым выражением, это не многомерный массив таким же образом, как:

int B[3][3];

Если вы скажете A[1], это оценит int *, аналогичный B[1], за исключением того, что вы можете сказать A[1] = (int *)0x4444;, но если вы сказали B[1] = (int *)0x4444;, вы получите ошибку компилятора, потому что B[1] фактически вычисленное значение, а не переменная. В B нет массива переменных int * - только некоторые вычисления, основанные на размере строки и адресе самого первого элемента массива.

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

MyFunction(int *array, int row, int col)
{
    int x = 0;
    for(int i=0 ; i<row ; i++ )
    {
        for(int j=0 ; j<col ; j++)
        {
            printf("%d ", array[x++]);
        }
        printf("\n");
    }
}

main()
{
    int array[3][3] = {0, 1, 2, 3, 4, 5, 6, 7, 8};
    MyFunction(array, 3, 3);
}