Ответ 1

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

1) Используйте массив массивов. Это можно использовать, только если границы вашего массива полностью определены во время компиляции или если ваш компилятор поддерживает VLA:

#define ROWS 4
#define COLS 5

void func(int array[ROWS][COLS])
{
  int i, j;

  for (i=0; i<ROWS; i++)
  {
    for (j=0; j<COLS; j++)
    {
      array[i][j] = i*j;
    }
  }
}

void func_vla(int rows, int cols, int array[rows][cols])
{
  int i, j;

  for (i=0; i<rows; i++)
  {
    for (j=0; j<cols; j++)
    {
      array[i][j] = i*j;
    }
  }
}

int main()
{
  int x[ROWS][COLS];

  func(x);
  func_vla(ROWS, COLS, x);
}

2) Использовать (динамически размещенный) массив указателей на (динамически размещаемые) массивы. Это используется главным образом, когда границы массива не известны до времени выполнения.

void func(int** array, int rows, int cols)
{
  int i, j;

  for (i=0; i<rows; i++)
  {
    for (j=0; j<cols; j++)
    {
      array[i][j] = i*j;
    }
  }
}

int main()
{
  int rows, cols, i;
  int **x;

  /* obtain values for rows & cols */

  /* allocate the array */
  x = malloc(rows * sizeof *x);
  for (i=0; i<rows; i++)
  {
    x[i] = malloc(cols * sizeof *x[i]);
  }

  /* use the array */
  func(x, rows, cols);

  /* deallocate the array */
  for (i=0; i<rows; i++)
  {
    free(x[i]);
  }
  free(x);
}

3) Используйте одномерный массив и исправьте индексы. Это может использоваться как со статически распределенными (фиксированного размера), так и с динамически размещаемыми массивами:

void func(int* array, int rows, int cols)
{
  int i, j;

  for (i=0; i<rows; i++)
  {
    for (j=0; j<cols; j++)
    {
      array[i*cols+j]=i*j;
    }
  }
}

int main()
{
  int rows, cols;
  int *x;

  /* obtain values for rows & cols */

  /* allocate the array */
  x = malloc(rows * cols * sizeof *x);

  /* use the array */
  func(x, rows, cols);

  /* deallocate the array */
  free(x);
}

4) Используйте динамически распределяемый VLA. Одним из преимуществ этого по сравнению с вариантом 2 является то, что существует одно выделение памяти; другое - требуется меньше памяти, поскольку массив указателей не требуется.

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

extern void func_vla(int rows, int cols, int array[rows][cols]);
extern void get_rows_cols(int *rows, int *cols);
extern void dump_array(const char *tag, int rows, int cols, int array[rows][cols]);

void func_vla(int rows, int cols, int array[rows][cols])
{
    for (int i = 0; i < rows; i++)
    {
        for (int j = 0; j < cols; j++)
        {
            array[i][j] = (i + 1) * (j + 1);
        }
    }
}

int main(void)
{
    int rows, cols;

    get_rows_cols(&rows, &cols);

    int (*array)[cols] = malloc(rows * cols * sizeof(array[0][0]));
    /* error check omitted */

    func_vla(rows, cols, array);
    dump_array("After initialization", rows, cols, array);

    free(array);
    return 0;
}

void dump_array(const char *tag, int rows, int cols, int array[rows][cols])
{
    printf("%s (%dx%d):\n", tag, rows, cols);
    for (int i = 0; i < rows; i++)
    {
        for (int j = 0; j < cols; j++)
            printf("%4d", array[i][j]);
        putchar('\n');
    }
}

void get_rows_cols(int *rows, int *cols)
{
    srand(time(0));           // Only acceptable because it is called once
    *rows = 5 + rand() % 10;
    *cols = 3 + rand() % 12;
}

(Смотрите srand() - зачем называть это только один раз?)

Ответ 2

Я не знаю, что вы подразумеваете под "данными, которые не теряются". Здесь, как вы передаете нормальный 2D-массив функции:

void myfunc(int arr[M][N]) { // M is optional, but N is required
  ..
}

int main() {
  int somearr[M][N];
  ...
  myfunc(somearr);
  ...
}

Ответ 3

2D-массив:

int sum(int array[][COLS], int rows)
{

}

3D-массив:

int sum(int array[][B][C], int A)
{

}

4D массив:

int sum(int array[][B][C][D], int A)
{

}

и массив nD:

int sum(int ar[][B][C][D][E][F].....[N], int A)
{

}

Ответ 4

Самый простой способ: передача 2D-массива переменной длины

_{Наиболее чистая техника для C & C++ заключается в следующем: передать двумерный массив как одномерный массив, а затем использовать как 2D внутри функции.}

void func(int row, int col, int* matrix){
    int i, j;
    for(i=0; i<row; i++){
        for(j=0; j<col; j++){
            printf("%d ", *(matrix + i*col + j)); // or better: printf("%d ", *matrix++);
        }
        printf("\n");
    }
}

int main(){
    int matrix[2][3] = { {1, 2, 3}, {7, 8, 9} };
    func(2, 3, matrix[0]);

    return 0;
}

Ответ 5

Если ваш компилятор не поддерживает VLA, вы можете сделать это простым способом, передав массив 2d как int * с помощью строки и col. В приемной функции регенерирует индекс массива 1d из индексов массива 2d.

int 
getid(int row, int x, int y) {
          return (row*x+y);
}
void 
printMatrix(int*arr, int row, int col) {
     for(int x = 0; x < row ; x++) {
             printf("\n");
             for (int y = 0; y <col ; y++) {
                 printf("%d  ",arr[getid(row, x,y)]);
             } 
     }                     
}

main()
{

   int arr[2][2] = {11,12,21,22};
   int row = 2, col = 2;

   printMatrix((int*)arr, row, col);

 }

Ответ 6

     #include <iostream>
     using namespace std;

     void printarray(int *a, int c,int r)
     {
        for (int i = 0; i < r; i++)
        {
            for (int j = 0; j < c; j++)
            {
                cout << "\t" << *(a + i*c + j) << "\t";  // a is a pointer refer to a 2D array
            }
        cout << endl << "\n\n";
        }
     }

     int main()
     {
         int array[4][4] = 
         {{1 ,2 ,3 ,4 },
          {12,13,14,5 },
          {11,16,15,6 },
          {10,9 ,8 ,7 }};

          printarray((int*)array,4,4);
          // here I use print function but u can use any other useful function like 
          //setArray((int *) array,4,4);

        return 0;
    }