Передача двумерного массива через указатель

Если вы не можете изменить foo () , вам нужно будет изменить m . Объявите его как float ** m и выделите память соответствующим образом. Затем вызовите foo () . Примерно так:

float **m = malloc(4 * sizeof(float *));
int i, j;
for (i = 0; i < 4; i++)
{
    m[i] = malloc(4 * sizeof(float));
    for (j = 0; j < 4; j++)
    {
        m[i][j] = i + j;
    }
}

Не забудьте после этого free () !

Если у вас есть компилятор, поддерживающий C99, текущий стандарт C, вы можете сделать это:

foo((float *[]){ m[0], m[1], m[2], m[3] });

(Обратите внимание, что это в точности то же самое, что и AndreyT ' s ответ, за исключением того, что в нем не требуется указывать имя временного массива)

Вы не можете. m несовместимо с аргументом foo . Вам придется использовать временный массив указателей.

int main()
{
    float m[4][4];
    int i,j;

    float *p[4];

    p[0] = m[0];
    p[1] = m[1];
    p[2] = m[2];
    p[3] = m[3];

    for (i = 0; i < 4; i++)
        for (j = 0; j < 4; j++)
            m[i][j] = i+j;


    foo(p);

void foo (float ** pm) то же самое, что void foo (float * pm []) , то есть не двумерный массив чисел с плавающей запятой. Это массив float * . Эти float * могут сами указывать на массивы float, но это отдельный вопрос.

typedef float Float4[4];

void foo(Float4 *pm)
{
  int i,j;
  for (i = 0; i < 4; i++)
    for (j = 0; j < 4; j++)
      printf("%f\n", pm[i][j]);
}

main()
{
  Float4 m[4];

  int i,j;
  for (i = 0; i < 4; i++)
    for (j = 0; j < 4; j++)
      m[i][j] = i+j;

  foo(m);
  return 0;
}

Если вы настаиваете на приведенном выше объявлении foo , то есть

void foo(float **pm)

, и на использовании встроенного 2D-массива, то есть

float m[4][4];

, тогда единственный способ сделать ваша foo работа с m состоит в том, чтобы создать дополнительный массив «индекса строки» и передать его вместо m

...
float *m_rows[4] = { m[0], m[1], m[2], m[3] };
foo(m_rows);

Нет возможности передать m на foo напрямую. Это невозможно. Тип параметра float ** безнадежно несовместим с типом аргумента float [4] [4] .

Кроме того, поскольку C99 вышесказанное может быть выражено более компактно как

foo((float *[]) { m[0], m[1], m[2], m[3] });

P.S. Если вы посмотрите внимательно, вы увидите, что это в основном то же самое, что Карл Норум предложил в своем ответе. За исключением того, что Карл malloc занимает память массива, что не является абсолютно необходимым.

Не работает ли foo (m) ?