Multidimensional arrays

Discussion in 'C++' started by James, Aug 19, 2003.

  1. James

    James Guest

    What's the best way of dynamically allocating a multidim array from the

    int **a = new int*[size];
    a[0] = new int[size];
    .... and so on


    int (*a)[10] = new int[10][10];

    by the way, how do we pass arrays delcared by the second way to
    functions? What really is the difference between (*a)[] and *a[]..
    actually i kind of understand the difference but it doesn't hit me that
    well.. I can't interpret what (*a)[] really means. Thanks!

    James, Aug 19, 2003
    1. Advertisements

  2. James

    Buster Guest

    I should have said 'any dimension except the first'.

    And here, 'every dimension except the first'.

    Buster, Aug 19, 2003
    1. Advertisements

  3. James

    Allan Bruce Guest

    I use a pointer to an array of pointers to an array of <type>, like this

    int **array;

    array = new int*[width];
    for (int loop=0; loop<width; ++loop)
    array[loop] = new int[height];

    // do some things with it like
    // array[3][4] = rand(); // or whatever

    for (loop=0; loop<width; ++loop)
    delete []array[loop];
    delete [] array;

    Allan Bruce, Aug 19, 2003
  4. James

    Mike Wahler Guest

    Mike Wahler, Aug 19, 2003
  5. James

    Axter Guest

    Here's a class that creates a 2 dimensional array very easily and

    template < class T, int ROW_T = 0, int COL_T = 0 >

    class dynamic_2d_array



    dynamic_2d_array(int row, int col):m_row(row),m_col(col),
    m_data((row!=0&&col!=0)?new T[row*col]:NULL){}

    dynamic_2d_array():m_row(ROW_T),m_col(COL_T), m_data(new

    {if (!COL_T || !ROW_T) {int x[ROW_T] = {{ROW_T}};int y[COL_T] =

    ~dynamic_2d_array(){if(m_data) delete []m_data;}

    T* operator[](int i) {return (m_data + (m_col*i));}

    T const*const operator[](int i) const {return (m_data + (m_col*i));}


    const int m_row;

    const int m_col;

    T* m_data;


    The above class can be delcare and used in the following maner:

    dynamic_2d_array < char > My_dynamic_2d_array(3, 20);

    My_dynamic_2d_array[2][11] = 99;

    cout << My_dynamic_2d_array[2][11] << endl;

    You can also use a vector<vector<char> > type object.

    For more information on this class, see the following link:

    Also check out the multidimensional class in the following link:
    Axter, Aug 19, 2003
    1. Advertisements

Ask a Question

Want to reply to this thread or ask your own question?

You'll need to choose a username for the site, which only take a couple of moments (here). After that, you can post your question and our members will help you out.