Przekazywanie tablicy 2D do funkcji C ++

Mam funkcję, którą chcę przyjąć jako parametr tablicę 2D o zmiennej wielkości.

Do tej pory mam to:

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

I zadeklarowałem tablicę gdzie indziej w moim kodzie:

double anArray[10][10];

Jednak wywołanie myFunction(anArray)powoduje błąd.

Nie chcę kopiować tablicy po jej przekazaniu. Wszelkie wprowadzone zmiany myFunctionpowinny zmienić stan anArray. Jeśli dobrze rozumiem, chcę przekazać jako argument wskaźnik do tablicy 2D. Funkcja musi także akceptować tablice o różnych rozmiarach. Na przykład [10][10]i [5][5]. W jaki sposób mogę to zrobić?

Istnieją trzy sposoby przekazania tablicy 2D do funkcji:

1. Ten parametr to tablica 2D

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

2. Parametr jest tablicą zawierającą wskaźniki

   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. Ten parametr jest wskaźnikiem do wskaźnika

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

Naprawiono rozmiar

1. Przekaż przez odniesienie

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

W C ++ przekazywanie tablicy przez referencję bez utraty informacji o wymiarze jest prawdopodobnie najbezpieczniejsze, ponieważ nie trzeba się martwić, że osoba dzwoniąca przekaże niepoprawny wymiar (flagi kompilatora podczas niedopasowania). Nie jest to jednak możliwe w przypadku tablic dynamicznych (Freestore); działa tylko w przypadku tablic automatycznych ( zwykle stosowych ), tzn. wymiary powinny być znane w czasie kompilacji.

2. Przejdź obok wskaźnika

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

Odpowiednikiem C poprzedniej metody jest przekazanie tablicy przez wskaźnik. Nie należy tego mylić z przekazywaniem zepsutego typu wskaźnika tablicy (3) , który jest powszechną, popularną metodą, choć mniej bezpieczną niż ta, ale bardziej elastyczną. Podobnie jak (1) , użyj tej metody, gdy wszystkie wymiary tablicy są ustalone i znane w czasie kompilacji. Zauważ, że podczas wywoływania funkcji należy podać adres tablicy, process_2d_array_pointer(&a)a nie adres pierwszego elementu przez zanik process_2d_array_pointer(a).

Zmienny rozmiar

Są one dziedziczone z C, ale są mniej bezpieczne, kompilator nie ma możliwości sprawdzenia, gwarantując, że osoba dzwoniąca przekazuje wymagane wymiary. Funkcja opiera się tylko na tym, co przekazujący wywołuje jako wymiar (wymiary). Są one bardziej elastyczne niż powyższe, ponieważ tablice o różnych długościach mogą być do nich przekazywane niezmiennie.

Należy pamiętać, że nie ma czegoś takiego jak przekazywanie tablicy bezpośrednio do funkcji w C [podczas gdy w C ++ można je przekazywać jako odwołanie (1) ]; (2) przekazuje wskaźnik do tablicy, a nie do samej tablicy. Zawsze przekazywanie tablicy bez zmian staje się operacją kopiowania wskaźnika, która jest ułatwiona przez naturę rozkładu tablicy na wskaźnik .

3. Przekaż (wartość) wskaźnik do zepsutego typu

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

Chociaż int array[][10]jest to dozwolone, nie poleciłbym go powyżej powyższej składni, ponieważ powyższa składnia wyjaśnia, że ​​identyfikator arrayjest pojedynczym wskaźnikiem do tablicy 10 liczb całkowitych, podczas gdy ta składnia wygląda na tablicę 2D, ale jest tym samym wskaźnikiem tablica 10 liczb całkowitych. Znamy tutaj liczbę elementów w jednym wierszu (tj. Rozmiar kolumny, tutaj 10), ale liczba wierszy jest nieznana i dlatego należy ją przekazać jako argument. W tym przypadku istnieje pewne bezpieczeństwo, ponieważ kompilator może oflagować się, gdy zostanie przekazany wskaźnik do tablicy o drugim wymiarze innym niż 10. Pierwszy wymiar jest częścią zmienną i można go pominąć. Zobacz tutaj uzasadnienie, dlaczego można pominąć tylko pierwszy wymiar.

4. Przekaż wskaźnik do wskaźnika

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

Znowu istnieje alternatywna składnia, int *array[10]która jest taka sama jak int **array. W tej składni [10]znak ignorowany jest, gdy rozpada się na wskaźnik, stając się w ten sposób int **array. Być może jest to tylko wskazówka dla wywołującego, że przekazywana tablica powinna mieć co najmniej 10 kolumn, nawet wtedy wymagana jest liczba wierszy. W każdym razie kompilator nie zgłasza żadnych naruszeń długości / rozmiaru (sprawdza tylko, czy przekazany typ jest wskaźnikiem do wskaźnika), dlatego wymaga liczenia wierszy i kolumn, ponieważ parametr ma tutaj sens.

Uwaga: (4) jest najmniej bezpieczną opcją, ponieważ prawie nie ma żadnej kontroli typu i jest najbardziej niewygodna. Do tej funkcji nie można legalnie przekazać tablicy 2D; C-FAQ potępia zwykłe obejście, int x[5][10]; process_pointer_2_pointer((int**)&x[0][0], 5, 10);ponieważ może potencjalnie prowadzić do nieokreślonego zachowania z powodu spłaszczenia tablicy. Właściwy sposób przekazywania tablicy w tej metodzie prowadzi nas do niewygodnej części, tzn. Potrzebujemy dodatkowej (zastępczej) tablicy wskaźników, z których każdy jej element wskazuje na odpowiedni rząd rzeczywistej tablicy, która ma być przekazana; ten surogat jest następnie przekazywany do funkcji (patrz poniżej); wszystko po to, aby wykonać tę samą pracę, co powyższe metody, które są bezpieczniejsze, czystsze i być może szybsze.

Oto program sterownika do testowania powyższych funkcji:

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

Modyfikacja pierwszej sugestii shengy, możesz użyć szablonów, aby funkcja zaakceptowała wielowymiarową zmienną tablicową (zamiast przechowywać tablicę wskaźników, którymi trzeba zarządzać i usuwać):

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

Instrukcje print mają na celu pokazanie, że tablice są przekazywane przez referencję (poprzez wyświetlanie adresów zmiennych)

Zaskoczony, że nikt jeszcze o tym nie wspominał, ale możesz po prostu szablonować na dowolnej 2D obsługującej [] [] semantykę.

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

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

Działa z dowolną std::vector<std::vector<T>>strukturą danych typu „tablicowego” 2D, taką jak typ zdefiniowany przez użytkownika, aby zmaksymalizować ponowne użycie kodu.

Możesz utworzyć szablon funkcji w ten sposób:

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

Następnie masz oba rozmiary wymiarów za pośrednictwem R i C. Dla każdego rozmiaru tablicy zostanie utworzona inna funkcja, więc jeśli twoja funkcja jest duża i wywołujesz ją z różnymi rozmiarami tablicy, może to być kosztowne. Możesz jednak użyć go jako opakowania funkcji takiej jak ta:

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

Traktuje tablicę jako jednowymiarową i wykorzystuje arytmetykę do ustalenia przesunięć indeksów. W takim przypadku należy zdefiniować szablon w następujący sposób:

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

anArray[10][10]nie jest wskaźnikiem do wskaźnika, to ciągły fragment pamięci odpowiedni do przechowywania 100 wartości typu double, który kompilator wie jak zaadresować, ponieważ określono wymiary. Musisz przekazać go do funkcji jako tablicy. Możesz pominąć rozmiar wymiaru początkowego w następujący sposób:

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

Nie pozwoli to jednak na przekazywanie tablic o ostatnim wymiarze innym niż dziesięć.

Najlepszym rozwiązaniem w C ++ jest użycie std::vector<std::vector<double> >: jest prawie tak samo wydajny i znacznie wygodniejszy.

Tablica jednowymiarowa rozpada się na wskaźnik wskazujący na pierwszy element w tablicy. Podczas gdy tablica 2D rozpada się na wskaźnik wskazujący pierwszy rząd. Prototypem funkcji powinno być -

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

Wolałbym std::vectorsurowe tablice.

Możesz zrobić coś takiego ...

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

Twój wynik będzie następujący ...

11.5  12.5
13.5  14.5

Oto przykład wektora macierzy wektorów

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

wynik:

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

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

Możemy użyć kilku sposobów przekazania tablicy 2D do funkcji:

• Za pomocą pojedynczego wskaźnika musimy typecastować tablicę 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;
  }

• Korzystanie z podwójnego wskaźnika W ten sposób również rzutujemy tablicę 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;
   }

Jedną ważną rzeczą do przekazywania tablic wielowymiarowych jest:

• First array dimension nie trzeba podawać.
• Second(any any further)dimension musi zostać określony.

1.Gdy tylko drugi wymiar jest dostępny globalnie (jako makro lub jako stała globalna)

`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.Korzystając z jednego wskaźnika : w tej metodzie musimy przerzucić tablicę 2D podczas przekazywania do funkcji.

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

Aby to zrobić, możesz skorzystać z narzędzia szablonów w C ++. Zrobiłem coś takiego:

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

Problem z tym podejściem polega na tym, że dla każdej wartości podanej kolumny, tworzona jest nowa definicja funkcji przy użyciu szablonu. więc,

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

tworzy szablon dwa razy, aby utworzyć 2 definicje funkcji (jedną, gdzie col = 3 i drugą, gdzie col = 5).

Jeśli chcesz przejść , musisz int a[2][3]wykonać void func(int** pp)następujące kroki pomocnicze.

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

func(pp);

Ponieważ pierwszy [2]można niejawnie określić, można go dodatkowo uprościć jako.

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

func(pp);

W przypadku, gdy chcesz przekazać do funkcji tablicę 2D o dynamicznym rozmiarze, użycie niektórych wskaźników może być dla Ciebie przydatne.

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

Możesz pominąć skrajny lewy wymiar, więc otrzymujesz dwie opcje:

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

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

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

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

To samo dotyczy wskaźników:

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

Rozpad N-wymiarowej tablicy na wskaźnik na tablicę wymiarową N-1 jest dozwolony przez standard C ++ , ponieważ możesz stracić skrajny lewy wymiar i nadal być w stanie poprawnie uzyskać dostęp do elementów tablicy z informacjami o wymiarach N-1.

Szczegóły tutaj

Chociaż tablice i wskaźniki nie są takie same : tablica może rozpaść się na wskaźnik, ale wskaźnik nie ma stanu dotyczącego rozmiaru / konfiguracji danych, na które wskazuje.

A char **jest wskaźnikiem do bloku pamięci zawierającego wskaźniki znaków , które same wskazują na bloki pamięci znaków. A char [][]to pojedynczy blok pamięci, który zawiera znaki. Ma to wpływ na to, jak kompilator przetłumaczy kod i jak będzie wyglądać końcowa wydajność.

Źródło