Передача 2D-массива в функцию C ++

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

Пока у меня есть это:

void myFunction(double** myArray){
     myArray[x][y] = 5;
     etc...
}

И я объявил массив в другом месте в моем коде:

double anArray[10][10];

Тем не менее, вызов myFunction(anArray)дает мне ошибку.

Я не хочу копировать массив, когда я передаю его. Любые изменения myFunctionдолжны изменить состояние anArray. Если я правильно понимаю, я хочу передать в качестве аргумента указатель на 2D-массив. Функция также должна принимать массивы разных размеров. Так например [10][10]и [5][5]. Как я могу это сделать?

Есть три способа передать 2D-массив в функцию:

1. Параметр представляет собой двумерный массив

   int array[10][10];
   void passFunc(int a[][10])
   {
       // ...
   }
   passFunc(array);
   

2. Параметр представляет собой массив, содержащий указатели

   int *array[10];
   for(int i = 0; i < 10; i++)
       array[i] = new int[10];
   void passFunc(int *a[10]) //Array containing pointers
   {
       // ...
   }
   passFunc(array);
   

3. Параметр является указателем на указатель

   int **array;
   array = new int *[10];
   for(int i = 0; i <10; i++)
       array[i] = new int[10];
   void passFunc(int **a)
   {
       // ...
   }
   passFunc(array);
   

Исправленный размер

1. Передать по ссылке

template <size_t rows, size_t cols>
void process_2d_array_template(int (&array)[rows][cols])
{
    std::cout << __func__ << std::endl;
    for (size_t i = 0; i < rows; ++i)
    {
        std::cout << i << ": ";
        for (size_t j = 0; j < cols; ++j)
            std::cout << array[i][j] << '\t';
        std::cout << std::endl;
    }
}

В C ++ передача массива по ссылке без потери информации об измерениях, вероятно, является наиболее безопасной, поскольку не нужно беспокоиться о том, что вызывающая сторона передаст неправильное измерение (флаги компилятора при несовпадении). Однако это невозможно с динамическими (freestore) массивами; он работает только для автоматических ( обычно стековых ) массивов, т.е. размерность должна быть известна во время компиляции.

2. Пройдите по указателю

void process_2d_array_pointer(int (*array)[5][10])
{
    std::cout << __func__ << std::endl;
    for (size_t i = 0; i < 5; ++i)
    {
        std::cout << i << ": ";
        for (size_t j = 0; j < 10; ++j)
            std::cout << (*array)[i][j] << '\t';
        std::cout << std::endl;
    }    
}

Эквивалент предыдущего метода на C передает массив по указателю. Это не следует путать с передачей типа потерянного указателя массива (3) , который является распространенным, популярным методом, хотя и менее безопасным, чем этот, но более гибким. Подобно (1) , используйте этот метод, когда все размеры массива фиксированы и известны во время компиляции. Обратите внимание, что при вызове функции должен передаваться адрес массива, process_2d_array_pointer(&a)а не адрес первого элемента при распаде process_2d_array_pointer(a).

Размер переменной

Они унаследованы от C, но менее безопасны, у компилятора нет способа проверить, гарантируя, что вызывающая сторона передает требуемые измерения. Функция полагается только на то, что передает вызывающая сторона в качестве измерения. Они более гибкие, чем описанные выше, поскольку массивы различной длины могут быть переданы им неизменно.

Следует помнить, что нет такой вещи, как передача массива непосредственно в функцию в C [в то время как в C ++ они могут передаваться как ссылка (1) ]; (2) передает указатель на массив, а не сам массив. Всегда передача массива как есть становится операцией копирования указателя, чему способствует природа распада массива в указатель .

3. Передать (значение) указатель на распавшийся тип

// int array[][10] is just fancy notation for the same thing
void process_2d_array(int (*array)[10], size_t rows)
{
    std::cout << __func__ << std::endl;
    for (size_t i = 0; i < rows; ++i)
    {
        std::cout << i << ": ";
        for (size_t j = 0; j < 10; ++j)
            std::cout << array[i][j] << '\t';
        std::cout << std::endl;
    }
}

Хотя int array[][10]это разрешено, я бы не рекомендовал использовать этот синтаксис выше, поскольку приведенный выше синтаксис проясняет, что идентификатор arrayпредставляет собой один указатель на массив из 10 целых чисел, хотя этот синтаксис выглядит как двумерный массив, но тот же указатель на массив из 10 целых чисел. Здесь мы знаем количество элементов в одной строке (то есть размер столбца, здесь 10), но количество строк неизвестно и, следовательно, должно быть передано в качестве аргумента. В этом случае есть некоторая безопасность, так как компилятор может пометить, когда передан указатель на массив со вторым измерением, не равным 10. Первое измерение является переменной частью и может быть опущено. См. Здесь обоснование того, почему только первое измерение может быть опущено.

4. Передать указатель на указатель

// int *array[10] is just fancy notation for the same thing
void process_pointer_2_pointer(int **array, size_t rows, size_t cols)
{
    std::cout << __func__ << std::endl;
    for (size_t i = 0; i < rows; ++i)
    {
        std::cout << i << ": ";
        for (size_t j = 0; j < cols; ++j)
            std::cout << array[i][j] << '\t';
        std::cout << std::endl;
    }
}

Опять же есть альтернативный синтаксис, int *array[10]который такой же, как int **array. В этом синтаксисе [10]игнорируется, поскольку он превращается в указатель, становясь тем самым int **array. Возможно, это просто подсказка вызывающей стороне, что переданный массив должен иметь не менее 10 столбцов, даже если требуется количество строк. В любом случае компилятор не помечает для каких-либо нарушений длины / размера (он только проверяет, является ли переданный тип указателем на указатель), следовательно, здесь имеет значение количество строк и столбцов в качестве параметра.

Примечание: (4) является наименее безопасным вариантом, так как он вряд ли имеет какую-либо проверку типов и является наиболее неудобным. Нельзя законно передать 2D-массив этой функции; C-FAQ осуждает обычный обходной путь, int x[5][10]; process_pointer_2_pointer((int**)&x[0][0], 5, 10);поскольку он может потенциально привести к неопределенному поведению из-за выравнивания массива. Правильный способ передачи массива в этом методе приводит нас к неудобной части, то есть нам нужен дополнительный (суррогатный) массив указателей, каждый элемент которого указывает на соответствующую строку фактического, подлежащего передаче массива; этот суррогат затем передается функции (см. ниже); все это для выполнения той же работы, что и вышеописанные методы, которые более безопасны, чище и, возможно, быстрее.

Вот программа-драйвер для проверки вышеуказанных функций:

#include <iostream>

// copy above functions here

int main()
{
    int a[5][10] = { { } };
    process_2d_array_template(a);
    process_2d_array_pointer(&a);    // <-- notice the unusual usage of addressof (&) operator on an array
    process_2d_array(a, 5);
    // works since a's first dimension decays into a pointer thereby becoming int (*)[10]

    int *b[5];  // surrogate
    for (size_t i = 0; i < 5; ++i)
    {
        b[i] = a[i];
    }
    // another popular way to define b: here the 2D arrays dims may be non-const, runtime var
    // int **b = new int*[5];
    // for (size_t i = 0; i < 5; ++i) b[i] = new int[10];
    process_pointer_2_pointer(b, 5, 10);
    // process_2d_array(b, 5);
    // doesn't work since b's first dimension decays into a pointer thereby becoming int**
}

В качестве модификации первого предложения shengy вы можете использовать шаблоны, чтобы заставить функцию принимать переменную многомерного массива (вместо хранения массива указателей, которые должны управляться и удаляться):

template <size_t size_x, size_t size_y>
void func(double (&arr)[size_x][size_y])
{
    printf("%p\n", &arr);
}

int main()
{
    double a1[10][10];
    double a2[5][5];

    printf("%p\n%p\n\n", &a1, &a2);
    func(a1);
    func(a2);

    return 0;
}

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

Удивило, что никто еще не упомянул об этом, но вы можете просто создать шаблон для чего-нибудь 2D, поддерживающего семантику [] [].

template <typename TwoD>
void myFunction(TwoD& myArray){
     myArray[x][y] = 5;
     etc...
}

// call with
double anArray[10][10];
myFunction(anArray);

Он работает с любой двумерной «массивоподобной» структурой данных, например std::vector<std::vector<T>>, или пользовательским типом, чтобы максимизировать повторное использование кода.

Вы можете создать шаблон функции следующим образом:

template<int R, int C>
void myFunction(double (&myArray)[R][C])
{
    myArray[x][y] = 5;
    etc...
}

Тогда у вас есть оба размера измерений с помощью R и C. Для каждого размера массива будет создана отдельная функция, поэтому, если ваша функция велика и вы вызываете ее с различными размерами массива, это может быть дорогостоящим. Вы можете использовать его как обертку над такой функцией:

void myFunction(double * arr, int R, int C)
{
    arr[x * C + y] = 5;
    etc...
}

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

template<int C, int R>
void myFunction(double (&myArray)[R][C])
{
    myFunction(*myArray, R, C);
}

anArray[10][10]это не указатель на указатель, это непрерывный кусок памяти, подходящий для хранения 100 значений типа double, который компилятор знает, как обращаться, потому что вы указали измерения. Вам нужно передать его в функцию в виде массива. Вы можете опустить размер исходного измерения следующим образом:

void f(double p[][10]) {
}

Однако это не позволит вам передавать массивы с последним измерением, кроме десяти.

Лучшее решение в C ++ - использовать std::vector<std::vector<double> >: оно почти столь же эффективно и значительно более удобно.

Одномерный массив распадается на указатель указателя, указывающий на первый элемент в массиве. В то время как 2D-массив распадается на указатель, указывающий на первую строку. Итак, прототип функции должен быть -

void myFunction(double (*myArray) [10]);

Я бы предпочел std::vectorсырые массивы.

Вы можете сделать что-то вроде этого ...

#include<iostream>

using namespace std;

//for changing values in 2D array
void myFunc(double *a,int rows,int cols){
    for(int i=0;i<rows;i++){
        for(int j=0;j<cols;j++){
            *(a+ i*rows + j)+=10.0;
        }
    }
}

//for printing 2D array,similar to myFunc
void printArray(double *a,int rows,int cols){
    cout<<"Printing your array...\n";
    for(int i=0;i<rows;i++){
        for(int j=0;j<cols;j++){
            cout<<*(a+ i*rows + j)<<"  ";
        }
    cout<<"\n";
    }
}

int main(){
    //declare and initialize your array
    double a[2][2]={{1.5 , 2.5},{3.5 , 4.5}};

    //the 1st argument is the address of the first row i.e
    //the first 1D array
    //the 2nd argument is the no of rows of your array
    //the 3rd argument is the no of columns of your array
    myFunc(a[0],2,2);

    //same way as myFunc
    printArray(a[0],2,2);

    return 0;
}

Ваш вывод будет следующим ...

11.5  12.5
13.5  14.5

Вот пример вектора матрицы векторов

#include <iostream>
#include <vector>
using namespace std;

typedef vector< vector<int> > Matrix;

void print(Matrix& m)
{
   int M=m.size();
   int N=m[0].size();
   for(int i=0; i<M; i++) {
      for(int j=0; j<N; j++)
         cout << m[i][j] << " ";
      cout << endl;
   }
   cout << endl;
}


int main()
{
    Matrix m = { {1,2,3,4},
                 {5,6,7,8},
                 {9,1,2,3} };
    print(m);

    //To initialize a 3 x 4 matrix with 0:
    Matrix n( 3,vector<int>(4,0));
    print(n);
    return 0;
}

вывод:

1 2 3 4
5 6 7 8
9 1 2 3

0 0 0 0
0 0 0 0
0 0 0 0

Мы можем использовать несколько способов передачи 2D-массива в функцию:

• Используя один указатель, мы должны типизировать 2D-массив.

  #include<bits/stdc++.h>
  using namespace std;
  
  
  void func(int *arr, int m, int n)
  {
      for (int i=0; i<m; i++)
      {
         for (int j=0; j<n; j++)
         {
            cout<<*((arr+i*n) + j)<<" ";
         }
         cout<<endl;
      }
  }
  
  int main()
  {
      int m = 3, n = 3;
      int arr[m][n] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
      func((int *)arr, m, n);
      return 0;
  }

• Использование двойного указателя Таким образом, мы также вводим 2d массив

    #include<bits/stdc++.h>
    using namespace std;

   void func(int **arr, int row, int col)
   {
      for (int i=0; i<row; i++)
      {
         for(int j=0 ; j<col; j++)
         {
           cout<<arr[i][j]<<" ";
         }
         printf("\n");
      }
   }

  int main()
  {
     int row, colum;
     cin>>row>>colum;
     int** arr = new int*[row];

     for(int i=0; i<row; i++)
     {
        arr[i] = new int[colum];
     }

     for(int i=0; i<row; i++)
     {
         for(int j=0; j<colum; j++)
         {
            cin>>arr[i][j];
         }
     }
     func(arr, row, colum);

     return 0;
   }

Одна важная вещь для передачи многомерных массивов:

• First array dimension не нужно указывать.
• Second(any any further)dimension должен быть указан.

1. Когда только второе измерение доступно глобально (или как макрос, или как глобальная константа)

`const int N = 3;

`void print(int arr[][N], int m)
{
int i, j;
for (i = 0; i < m; i++)
  for (j = 0; j < N; j++)
    printf("%d ", arr[i][j]);
}`

int main()
{
int arr[][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
print(arr, 3);
return 0;
}`

2. Использование одного указателя : в этом методе мы должны типизировать 2D-массив при переходе к функции.

`void print(int *arr, int m, int n)
{
int i, j;
for (i = 0; i < m; i++)
  for (j = 0; j < n; j++)
    printf("%d ", *((arr+i*n) + j));
 }

`int main()
{
int arr[][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
int m = 3, n = 3;

// We can also use "print(&arr[0][0], m, n);"
print((int *)arr, m, n);
return 0;
}`

Вы можете использовать шаблон в C ++, чтобы сделать это. Я сделал что-то вроде этого:

template<typename T, size_t col>
T process(T a[][col], size_t row) {
...
}

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

int some_mat[3][3], another_mat[4,5];
process(some_mat, 3);
process(another_mat, 4);

создает экземпляр шаблона дважды, чтобы получить 2 определения функции (одно, где col = 3 и одно, где col = 5).

Если вы хотите перейти int a[2][3]к void func(int** pp)вам, необходимо вспомогательные действия, как указано ниже.

int a[2][3];
int* p[2] = {a[0],a[1]};
int** pp = p;

func(pp);

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

int a[][3];
int* p[] = {a[0],a[1]};
int** pp = p;

func(pp);

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

void func1(int *arr, int n, int m){
    ...
    int i_j_the_element = arr[i * m + j];  // use the idiom of i * m + j for arr[i][j] 
    ...
}

void func2(){
    ...
    int arr[n][m];
    ...
    func1(&(arr[0][0]), n, m);
}

Вам разрешено опускать крайнее левое измерение, поэтому у вас есть два варианта:

void f1(double a[][2][3]) { ... }

void f2(double (*a)[2][3]) { ... }

double a[1][2][3];

f1(a); // ok
f2(a); // ok 

Это то же самое с указателями:

// compilation error: cannot convert ‘double (*)[2][3]’ to ‘double***’ 
// double ***p1 = a;

// compilation error: cannot convert ‘double (*)[2][3]’ to ‘double (**)[3]’
// double (**p2)[3] = a;

double (*p3)[2][3] = a; // ok

// compilation error: array of pointers != pointer to array
// double *p4[2][3] = a;

double (*p5)[3] = a[0]; // ok

double *p6 = a[0][1]; // ok

Распад N-мерного массива на указатель на N-1-мерный массив разрешен стандартом C ++ , так как вы можете потерять крайнее левое измерение и все еще иметь возможность правильно обращаться к элементам массива с N-1-мерной информацией.

Подробности здесь

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

A char **- указатель на блок памяти, содержащий символьные указатели , которые сами указывают на блоки памяти символов. A char [][]- это отдельный блок памяти, который содержит символы. Это влияет на то, как компилятор переводит код и как будет выглядеть конечная производительность.

Источник