Question

int java declaration of array like this
int a[][]=new int[3][3] works but in c++ not why? please help me i have not used c++ a long time so please help me

Answer 1

I once had this same problem and ended up creating a class for it. Basically it’s stored as a pointer of single dimension array and the pointers are manipulated a bit so that it acts just like a 2D array (matrix). Here’s the code I used:

#include <utility>
#include <memory.h>

template <typename T>
class Matrix
{
protected:
    T** m;
    int x,y;

    __forceinline void setMatrix()
    {
        assert(x > 0);
        assert(y > 0);
        m = new T*[y];
        m[0] = new T[x*y];
        for (int i = 1; i < y; ++i)
        {
            m[i] = m[i-1] + x;
        }
    }
public:
    Matrix():m(0),x(0),y(0){}
    Matrix(int rows, int cols):x(cols),y(rows),m(0)
    {
        setMatrix();
    }

    Matrix(const Matrix<T>& mat):m(0),x(mat.x),y(mat.y)
    {
        setMatrix();
        memcpy_s(m[0], x*y, mat.m[0], x*y);
    }

    ~Matrix()
    {
        if (m)
        {
            delete[] m[0];
            delete[] m;
        }
    }

    void fill(const T& val)
    {
        if (m)
        {
            for (int j = 0; j < y; ++j)
                for (int i = 0; i < x; ++i)
                    m[j][i] = val;
        }
    }

    T& at(int row, int col)
    {
        assert(row >= 0 && row < y);
        assert(col >= 0 && col < x);
        return m[row][col];
    }

    const T& at(int row, int col) const
    {
        assert(row >= 0 && row < y);
        assert(col >= 0 && col < x);
        return m[row][col];
    }

    T* operator[](int row)
    {
        assert(row >= 0 && row < y);
        return m[row];
    }

    const T* operator[](int row) const
    {
        assert(row >= 0 && row < y);
        m[row];
    }

    T& operator ()(int row, int col)
    {
        assert(row >= 0 && row < y);
        assert(col >= 0 && col < x);
        return m[row][col];
    }

    const T& operator ()(int row, int col) const
    {
        assert(row >= 0 && row < y);
        assert(col >= 0 && col < x);
        return m[row][col];
    }

    void swap(Matrix<T>& mat)
    {
        std::swap(m, mat.m);
        std::swap(x, mat.x);
        std::swap(y, mat.y);
    }

    const Matrix& operator = (const Matrix<T>& rhs)
    {
        Matrix temp(rhs);
        swap(temp);
        return *this;
    }

    //

    int getRows() const
    {
        return y;
    }

    int getColumns() const
    {
        return x;
    }
};

Usage would be like:

typedef Matrix<int> IntMatrix;
IntMatrix mat(2,3); // Creates a 2x3 matrix to store integers.
mat.fill(0); // Fill it with zeroes.
int val02 = mat[0][2]; // Unsafe way to retrieve values
int val12 = mat(1,2); // Safe way to retrieve values;
mat(0,1) = 10; // Assign values directly to the matrix.

You can also extend this class so that it has other matrix related function in it.