Übergeben eines 2D-Arrays an eine C ++ - Funktion

Ich habe eine Funktion, die ich als Parameter für ein 2D-Array mit variabler Größe verwenden möchte.

Bisher habe ich Folgendes:

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

Und ich habe an anderer Stelle in meinem Code ein Array deklariert:

double anArray[10][10];

Ein Anruf myFunction(anArray)gibt mir jedoch einen Fehler.

Ich möchte das Array nicht kopieren, wenn ich es übergebe. Alle vorgenommenen Änderungen myFunctionsollten den Status von ändern anArray. Wenn ich das richtig verstehe, möchte ich nur einen Zeiger auf ein 2D-Array als Argument übergeben. Die Funktion muss auch Arrays unterschiedlicher Größe akzeptieren. So zum Beispiel [10][10]und [5][5]. Wie kann ich das machen?

Es gibt drei Möglichkeiten, ein 2D-Array an eine Funktion zu übergeben:

1. Der Parameter ist ein 2D-Array

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

2. Der Parameter ist ein Array, das Zeiger enthält

   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. Der Parameter ist ein Zeiger auf einen Zeiger

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

Feste Größe

1. Als Referenz übergeben

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

In C ++ ist das Übergeben des Arrays als Referenz ohne Verlust der Dimensionsinformationen wahrscheinlich das sicherste, da man sich keine Sorgen machen muss, dass der Aufrufer eine falsche Dimension übergibt (Compiler-Flags bei Nichtübereinstimmung). Dies ist jedoch mit dynamischen (Freestore-) Arrays nicht möglich. Es funktioniert nur für automatische ( normalerweise stapelweise lebende ) Arrays, dh die Dimensionalität sollte zur Kompilierungszeit bekannt sein.

2. Übergeben Sie den Zeiger

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

Das C-Äquivalent der vorherigen Methode übergibt das Array per Zeiger. Dies sollte nicht mit der Übergabe des verfallenen Zeigertyps des Arrays verwechselt werden (3) ist die übliche, beliebte Methode, wenn auch weniger sicher als diese, aber flexibler. Verwenden Sie diese Methode wie in (1) , wenn alle Dimensionen des Arrays zur Kompilierungszeit festgelegt und bekannt sind. Beachten Sie, dass beim Aufrufen der Funktion die Adresse des Arrays übergeben werden sollte process_2d_array_pointer(&a)und nicht die Adresse des ersten Elements durch Zerfall process_2d_array_pointer(a).

Variable Größe

Diese werden von C geerbt, sind jedoch weniger sicher. Der Compiler kann dies nicht überprüfen und garantiert, dass der Aufrufer die erforderlichen Dimensionen übergibt. Die Funktion basiert nur auf dem, was der Anrufer als Dimension (en) übergibt. Diese sind flexibler als die oben genannten, da Arrays unterschiedlicher Länge immer an sie übergeben werden können.

Es ist zu beachten, dass es in C kein direktes Übergeben eines Arrays an eine Funktion gibt [während sie in C ++ als Referenz übergeben werden können (1) ]; (2) übergibt einen Zeiger auf das Array und nicht auf das Array selbst. Das Übergeben eines Arrays im Ist-Zustand wird zu einer Zeigerkopieroperation, die durch die Art des Zerfalls des Arrays in einen Zeiger erleichtert wird .

3. Übergeben Sie (Wert) einen Zeiger auf den verfallenen Typ

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

Obwohl dies int array[][10]zulässig ist, würde ich es nicht über die obige Syntax empfehlen, da die obige Syntax deutlich macht, dass der Bezeichner arrayein einzelner Zeiger auf ein Array mit 10 Ganzzahlen ist, während diese Syntax wie ein 2D-Array aussieht, aber der gleiche Zeiger auf ist ein Array von 10 ganzen Zahlen. Hier kennen wir die Anzahl der Elemente in einer einzelnen Zeile (dh die Spaltengröße, hier 10), aber die Anzahl der Zeilen ist unbekannt und muss daher als Argument übergeben werden. In diesem Fall besteht eine gewisse Sicherheit, da der Compiler markieren kann, wenn ein Zeiger auf ein Array mit einer zweiten Dimension ungleich 10 übergeben wird. Die erste Dimension ist der variierende Teil und kann weggelassen werden. Hier finden Sie die Gründe, warum nur die erste Dimension weggelassen werden darf.

4. Übergeben Sie den Zeiger auf einen Zeiger

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

Wieder gibt es eine alternative Syntax int *array[10], die dieselbe ist wie int **array. In dieser Syntax wird das [10]ignoriert, wenn es in einen Zeiger zerfällt, wodurch es wird int **array. Vielleicht ist es nur ein Hinweis für den Aufrufer, dass das übergebene Array mindestens 10 Spalten haben sollte, auch wenn eine Zeilenanzahl erforderlich ist. In jedem Fall kennzeichnet der Compiler keine Längen- / Größenverletzungen (er prüft nur, ob der übergebene Typ ein Zeiger auf Zeiger ist), weshalb hier sowohl Zeilen- als auch Spaltenanzahl als Parameter erforderlich sind.

Hinweis: (4) ist die am wenigsten sichere Option, da kaum eine Typprüfung durchgeführt wird und die unpraktischste ist. Ein 2D-Array kann dieser Funktion nicht legitim übergeben werden. C-FAQ verurteilt die übliche Problemumgehung, int x[5][10]; process_pointer_2_pointer((int**)&x[0][0], 5, 10);da dies möglicherweise zu undefiniertem Verhalten aufgrund von Array-Abflachung führen kann. Die richtige Art, ein Array in dieser Methode zu übergeben, bringt uns zu dem unbequemen Teil, dh wir benötigen ein zusätzliches (Ersatz-) Array von Zeigern, wobei jedes seiner Elemente auf die jeweilige Zeile des tatsächlich zu übergebenden Arrays zeigt. Dieser Ersatz wird dann an die Funktion übergeben (siehe unten). All dies, um die gleiche Arbeit wie die oben genannten Methoden zu erledigen, die sicherer, sauberer und vielleicht schneller sind.

Hier ist ein Treiberprogramm zum Testen der oben genannten Funktionen:

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

Als Modifikation von Shengys erstem Vorschlag können Sie Vorlagen verwenden, damit die Funktion eine mehrdimensionale Arrayvariable akzeptiert (anstatt ein Array von Zeigern zu speichern, die verwaltet und gelöscht werden müssen):

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

Die print-Anweisungen sollen zeigen, dass die Arrays als Referenz übergeben werden (indem die Adressen der Variablen angezeigt werden).

Überrascht, dass dies noch niemand erwähnt hat, aber Sie können einfach eine 2D-Vorlage für [] [] -Semantik erstellen.

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

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

Es funktioniert mit jeder "Array-ähnlichen" 2D-Datenstruktur, z. B. std::vector<std::vector<T>>oder einem benutzerdefinierten Typ, um die Wiederverwendung von Code zu maximieren.

Sie können eine Funktionsvorlage wie folgt erstellen:

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

Dann haben Sie beide Dimensionsgrößen über R und C. Für jede Arraygröße wird eine andere Funktion erstellt. Wenn Ihre Funktion also groß ist und Sie sie mit einer Vielzahl unterschiedlicher Arraygrößen aufrufen, kann dies kostspielig sein. Sie können es jedoch als Wrapper für eine Funktion wie diese verwenden:

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

Es behandelt das Array als eindimensional und verwendet Arithmetik, um die Offsets der Indizes zu ermitteln. In diesem Fall würden Sie die Vorlage folgendermaßen definieren:

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

anArray[10][10]ist kein Zeiger auf einen Zeiger, sondern ein zusammenhängender Speicherblock, der zum Speichern von 100 Werten vom Typ double geeignet ist. Der Compiler kann diese adressieren, da Sie die Dimensionen angegeben haben. Sie müssen es an eine Funktion als Array übergeben. Sie können die Größe der anfänglichen Dimension wie folgt weglassen:

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

Auf diese Weise können Sie jedoch keine Arrays mit der letzten Dimension außer zehn übergeben.

Die beste Lösung in C ++ ist die Verwendung std::vector<std::vector<double> >: Sie ist fast genauso effizient und wesentlich bequemer.

Ein eindimensionales Array zerfällt in einen Zeiger, der auf das erste Element im Array zeigt. Während ein 2D-Array zu einem Zeiger zerfällt, der auf die erste Zeile zeigt. Der Funktionsprototyp sollte also sein -

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

Ich würde std::vectorrohen Arrays vorziehen .

Sie können so etwas tun ...

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

Ihre Ausgabe wird wie folgt sein ...

11.5  12.5
13.5  14.5

Hier ist ein Beispiel für eine Vektormatrix

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

Ausgabe:

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

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

Wir können ein 2D-Array auf verschiedene Arten an eine Funktion übergeben:

• Mit einem einzelnen Zeiger müssen wir das 2D-Array typisieren.

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

• Verwenden des Doppelzeigers Auf diese Weise wird auch das 2d-Array typisiert

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

Eine wichtige Sache für die Übergabe mehrdimensionaler Arrays ist:

• First array dimension muss nicht angegeben werden.
• Second(any any further)dimension muss angegeben werden.

1.Wenn nur die zweite Dimension global verfügbar ist (entweder als Makro oder als globale Konstante)

`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.Verwenden eines einzelnen Zeigers : Bei dieser Methode müssen wir das 2D-Array bei der Übergabe an die Funktion typisieren .

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

Sie können dazu die Vorlagenfunktion in C ++ verwenden. Ich habe so etwas gemacht:

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

Das Problem bei diesem Ansatz besteht darin, dass für jeden von Ihnen angegebenen Wert von col die neue Funktionsdefinition mithilfe der Vorlage instanziiert wird. damit,

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

Instanziiert die Vorlage zweimal, um zwei Funktionsdefinitionen zu erstellen (eine mit col = 3 und eine mit col = 5).

Wenn Sie weitergeben wollen int a[2][3]zu void func(int** pp)müssen Sie Hilfsschritte wie folgt.

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

func(pp);

Da die erste [2]implizit angegeben werden kann, kann sie weiter vereinfacht werden als.

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

func(pp);

Wenn Sie ein dynamisches 2D-Array an eine Funktion übergeben möchten, kann die Verwendung einiger Zeiger für Sie hilfreich sein.

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

Sie dürfen die Dimension ganz links weglassen und haben zwei Möglichkeiten:

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

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

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

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

Dies gilt auch für Zeiger:

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

Der Zerfall eines N-dimensionalen Arrays in einen Zeiger auf ein N-1-dimensionales Array ist nach dem C ++ - Standard zulässig , da Sie die am weitesten links stehende Dimension verlieren und dennoch korrekt auf Array-Elemente mit N-1-Dimensionsinformationen zugreifen können.

Details hier

Obwohl, Arrays und Zeiger sind nicht die gleichen : eine Anordnung in einen Zeiger des Zerfalls kann, sondern ein Zeiger nicht trägt Zustand über die Größe / Konfiguration der Daten , auf die sie verweist.

A char **ist ein Zeiger auf einen Speicherblock, der Zeichenzeiger enthält , die selbst auf Speicherblöcke von Zeichen zeigen. A char [][]ist ein einzelner Speicherblock, der Zeichen enthält. Dies hat Auswirkungen darauf, wie der Compiler den Code übersetzt und wie die endgültige Leistung sein wird.

Quelle