Passer un tableau 2D à une fonction C ++

J'ai une fonction que je veux prendre, en paramètre, un tableau 2D de taille variable.

Jusqu'à présent, j'ai ceci:

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

Et j'ai déclaré un tableau ailleurs dans mon code:

double anArray[10][10];

Cependant, appeler myFunction(anArray)me donne une erreur.

Je ne veux pas copier le tableau lorsque je le passe. Toute modification apportée à myFunctiondevrait modifier l'état de anArray. Si je comprends bien, je veux seulement passer en argument un pointeur vers un tableau 2D. La fonction doit également accepter des tableaux de différentes tailles. Ainsi, par exemple, [10][10]et [5][5]. Comment puis-je faire ceci?

Il existe trois façons de passer un tableau 2D à une fonction:

1. Le paramètre est un tableau 2D

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

2. Le paramètre est un tableau contenant des pointeurs

   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. Le paramètre est un pointeur sur un pointeur

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

Taille fixe

1. Passer par référence

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;
    }
}

En C ++, passer le tableau par référence sans perdre les informations de dimension est probablement le plus sûr, car il n'est pas nécessaire de se soucier que l'appelant passe une dimension incorrecte (drapeaux du compilateur en cas de non-correspondance). Cependant, cela n'est pas possible avec les tableaux dynamiques (magasin libre); cela ne fonctionne que pour les tableaux automatiques ( généralement empilés ), c'est-à-dire que la dimensionnalité doit être connue au moment de la compilation.

2. Passer par le pointeur

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;
    }    
}

L'équivalent C de la méthode précédente passe le tableau par pointeur. Cela ne doit pas être confondu avec le passage par le type de pointeur pourri du tableau (3) , qui est la méthode courante et populaire, bien que moins sûre que celle-ci mais plus flexible. Comme (1) , utilisez cette méthode lorsque toutes les dimensions du tableau sont fixes et connues au moment de la compilation. Notez que lors de l'appel de la fonction, l'adresse du tableau doit être transmise process_2d_array_pointer(&a)et non l'adresse du premier élément par décroissance process_2d_array_pointer(a).

Taille variable

Celles-ci sont héritées de C mais sont moins sûres, le compilateur n'a aucun moyen de vérifier, garantissant que l'appelant passe les dimensions requises. La fonction ne dépend que de ce que l'appelant passe comme dimension (s). Celles-ci sont plus flexibles que les précédentes, car des tableaux de différentes longueurs peuvent leur être transmis invariablement.

Il faut se rappeler qu'il n'y a rien de tel que de passer un tableau directement à une fonction en C [tandis qu'en C ++, ils peuvent être passés comme référence (1) ]; (2) transmet un pointeur au tableau et non au tableau lui-même. Toujours passer un tableau tel quel devient une opération de copie de pointeur qui est facilitée par la nature du tableau de se désintégrer en un pointeur .

3. Passez (valeur) un pointeur sur le type pourri

// 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;
    }
}

Bien que cela int array[][10]soit autorisé, je ne le recommanderais pas par-dessus la syntaxe ci-dessus, car la syntaxe ci-dessus indique clairement que l'identifiant arrayest un pointeur unique vers un tableau de 10 entiers, tandis que cette syntaxe ressemble à un tableau 2D mais est le même pointeur vers un tableau de 10 entiers. Ici, nous connaissons le nombre d'éléments dans une seule ligne (c'est-à-dire la taille de la colonne, 10 ici) mais le nombre de lignes est inconnu et doit donc être passé en argument. Dans ce cas, il y a une certaine sécurité car le compilateur peut signaler lorsqu'un pointeur vers un tableau avec une deuxième dimension non égale à 10 est passé. La première dimension est la partie variable et peut être omise. Voir ici pour la raison pour laquelle seule la première dimension peut être omise.

4. Passer un pointeur à un pointeur

// 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;
    }
}

Encore une fois, il existe une syntaxe alternative int *array[10]qui est la même que int **array. Dans cette syntaxe, le [10]est ignoré car il se désintègre en un pointeur devenant ainsi int **array. C'est peut-être juste un signal à l'appelant que le tableau passé doit avoir au moins 10 colonnes, même si le nombre de lignes est requis. Dans tous les cas, le compilateur ne signale aucune violation de longueur / taille (il vérifie uniquement si le type transmis est un pointeur vers un pointeur), nécessitant donc à la fois le nombre de lignes et de colonnes comme paramètre est logique ici.

Remarque: (4) est l'option la moins sûre car elle ne comporte quasiment aucun contrôle de type et est la plus gênante. On ne peut légitimement passer un tableau 2D à cette fonction; C-FAQ condamne la solution de contournement habituelle int x[5][10]; process_pointer_2_pointer((int**)&x[0][0], 5, 10);car cela peut potentiellement conduire à un comportement indéfini en raison de l'aplatissement de la baie. La bonne façon de passer un tableau dans cette méthode nous amène à la partie gênante, c'est-à-dire que nous avons besoin d'un tableau supplémentaire (de substitution) de pointeurs avec chacun de ses éléments pointant vers la ligne respective du tableau réel à passer; ce substitut est ensuite transmis à la fonction (voir ci-dessous); tout cela pour faire le même travail que les méthodes ci-dessus qui sont plus sûres, plus propres et peut-être plus rapides.

Voici un programme pilote pour tester les fonctions ci-dessus:

#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**
}

Une modification de la première suggestion de shengy, vous pouvez utiliser des modèles pour que la fonction accepte une variable de tableau multidimensionnel (au lieu de stocker un tableau de pointeurs qui doivent être gérés et supprimés):

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;
}

Les instructions print sont là pour montrer que les tableaux sont passés par référence (en affichant les adresses des variables)

Surpris que personne ne l'ait encore mentionné, mais vous pouvez simplement créer un modèle sur tout ce qui prend en charge la sémantique [] [] 2D.

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

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

Il fonctionne avec n'importe quelle infrastructure de données 2D de type tableau, telle que std::vector<std::vector<T>>, ou un type défini par l'utilisateur pour maximiser la réutilisation du code.

Vous pouvez créer un modèle de fonction comme celui-ci:

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

Ensuite, vous avez les deux tailles de dimension via R et C. Une fonction différente sera créée pour chaque taille de tableau, donc si votre fonction est grande et que vous l'appelez avec une variété de tailles de tableau différentes, cela peut être coûteux. Vous pouvez cependant l'utiliser comme wrapper sur une fonction comme celle-ci:

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

Il traite le tableau comme unidimensionnel et utilise l'arithmétique pour déterminer les décalages des index. Dans ce cas, vous définiriez le modèle comme ceci:

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

anArray[10][10]n'est pas un pointeur vers un pointeur, c'est un morceau de mémoire contigu approprié pour stocker 100 valeurs de type double, que le compilateur sait comment traiter car vous avez spécifié les dimensions. Vous devez le passer à une fonction sous forme de tableau. Vous pouvez omettre la taille de la dimension initiale, comme suit:

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

Cependant, cela ne vous permettra pas de passer des tableaux avec la dernière dimension autre que dix.

La meilleure solution en C ++ est d'utiliser std::vector<std::vector<double> >: elle est presque aussi efficace et nettement plus pratique.

Le tableau unidimensionnel se désintègre en un pointeur pointeur pointant vers le premier élément du tableau. Alors qu'un tableau 2D se désintègre en un pointeur pointant vers la première ligne. Ainsi, le prototype de fonction devrait être -

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

Je préfère std::vectorles tableaux bruts.

Vous pouvez faire quelque chose comme ça ...

#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;
}

Votre sortie sera la suivante ...

11.5  12.5
13.5  14.5

Voici un exemple de matrice de vecteurs

#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;
}

production:

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

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

Nous pouvons utiliser plusieurs façons de passer un tableau 2D à une fonction:

• En utilisant un seul pointeur, nous devons transtyper le tableau 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;
  }

• Utilisation du pointeur double De cette façon, nous avons également transtypé le tableau 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;
   }

Une chose importante pour passer des tableaux multidimensionnels est:

• First array dimension n'a pas besoin d'être spécifié.
• Second(any any further)dimension doit être spécifié.

1.Lorsque seule la deuxième dimension est disponible à l'échelle mondiale (sous forme de macro ou de constante globale)

`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.Utilisation d'un seul pointeur : Dans cette méthode, nous devons transtyper le tableau 2D lors du passage à la fonction.

`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;
}`

Vous pouvez utiliser la fonction de modèle en C ++ pour ce faire. J'ai fait quelque chose comme ça:

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

le problème avec cette approche est que pour chaque valeur de col que vous fournissez, la nouvelle définition d'une fonction est instanciée à l'aide du modèle. alors,

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

instancie le modèle deux fois pour produire 2 définitions de fonction (une où col = 3 et une où col = 5).

Si vous voulez passer int a[2][3]à void func(int** pp)vous avez besoin d'étapes auxiliaires comme suit.

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

func(pp);

Comme le premier [2]peut être implicitement spécifié, il peut être encore simplifié au fur et à mesure.

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

func(pp);

Dans le cas où vous souhaitez passer un tableau 2D de taille dynamique à une fonction, l'utilisation de certains pointeurs pourrait fonctionner pour vous.

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);
}

Vous êtes autorisé à omettre la dimension la plus à gauche et vous vous retrouvez donc avec deux options:

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

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

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

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

C'est la même chose avec les pointeurs:

// 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

La désintégration d'un tableau à N dimensions vers un pointeur vers un tableau à N-1 dimensions est autorisée par la norme C ++ , car vous pouvez perdre la dimension la plus à gauche et toujours pouvoir accéder correctement aux éléments du tableau avec les informations de dimension N-1.

Détails ici

Cependant, les tableaux et les pointeurs ne sont pas les mêmes : un tableau peut se désintégrer en un pointeur, mais un pointeur ne porte pas d'état sur la taille / configuration des données vers lesquelles il pointe.

A char **est un pointeur vers un bloc de mémoire contenant des pointeurs de caractères , qui pointent eux-mêmes vers des blocs de mémoire de caractères. A char [][]est un bloc de mémoire unique qui contient des caractères. Cela a un impact sur la façon dont le compilateur traduit le code et sur les performances finales.

La source