Q:

question on arrays in c++

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

A:

In C++ you would just say int a[3][3];. C++ doesn't require all arrays and objects to be declared with new.
EDIT:
For a dynamic size n you can't use stack based arrays.
Probably the best way is a vector of vectors:
std::vector<std::vector<int> > a;
a.resize(n);
for(int i = 0; i < n; ++i)
{
    a[i].resize(n);
}

A:

Generally speaking, you should avoid using arrays in C++ at all. While there are special cases where they're (nearly) the only choice, your first choice should generally be to use a std::vector instead. In this case, what you want becomes fairly straightforward:
// vector of 3 ints, each initialized to 0
std::vector<int> init(3, 0);   

// vector of three vectors of int, each initialized to the value of 'init':
std::vector<std::vector<int> > a(3, init);

A:

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.

