Ytukyg

How am I supposed to pass static 2d array to function in cpp as an argument? I tried something like that:

 void foo(int (&tab)[N][N]) {

    // function body

 }



int main() {

  int n;

  cin >> n;

  int tab[n][n];

  foo(tab); // doesn't work

  return 0;

}

I get "no matching function error" when I try to call foo.

I need static arrays, because vectors are too slow for my needs. I would like to avoid declaring array with 10000 rows and columns, too. Moreover, I would want to use functions, because it will make my code readable. Is there any solution for this problem which will meet my expectations?

The classical C++ solution would involve using vectors of vectors. If it's not suitable (because you want more speed or more control over memory), you can define your own class for a square 2-D array.

One idea I used in my code is, implement it using an underlying 1-D vector, with accessor method returning a pointer.

struct My_2D_Array

{

    explicit My_2D_Array(size_t n):

        m_size(n),

        m_data(n * n)

    {

    }



    int* operator(size_t i)

    {

        return m_data.data() + i * m_size;

    }

    size_t m_size;

    std::vector<int> m_data;

};

This not only lacks all sanity checks, and also makes bound-checked access impossible (because the accessor returns a bare pointer), but will work as a quick-and-dirty solution.

Usage in your code:

int foo(My_2D_Array& matrix)

{

    // example

    return matrix[2][3] + matrix[3][2];

}



int main()

{

    int n;

    cin >> n;

    My_2D_Array tab(n);

    foo(tab);

    return 0;

}

This idea is highly customizable - you can make the code for My_2D_Array as simple or as clever as you want. For example, if you still don't like usage of vector, even though it's 1-D, you can manage (allocate/deallocate) your memory separately, and store int*, instead of vector<int>, in My_2D_Array.

With cin >> n;int tab[n][n];, you declare a variable length array (i.e. an array which's dimensions are not compile-time-constants).
You have two problems here: First, they are not supported by standard C++, and second they are not compatible with fixed size array parameters you introduced.
If you declare your array with compile time known size, however, it will work:

#define N 10



void foo(int (&tab)[N][N]) {

    cout << tab[1][1] << endl;

}



int main() {

    int tab[N][N] = {};

    tab[1][1]=15;

    foo(tab);

    return 0;

}

Just use a vector<> of vector<int>. No need for mucking around with non-standard arrays.