I don't like the phrase "is always (physically) one dimension array".

They are not. But all array elements are always stored contiguous.

Arne

    Surprising; I'd imagined that C++ was similar to C insofar
as "shared concepts" are concerned, but from what you say it
must be quite different.

    I cannot answer for C++ because I don't know the language,
and from what you said earlier it must be very different from C.
But in C, this outline is easy to achieve, and in fact the
resulting structure has some similarities to Java's arrays:

    /* C source (no error checking) */
    Student **array;
    array = malloc(3 * sizeof *array);
    array[0] = malloc(9 * sizeof *array[0]);
    array[0][0] = newStudent();
    array[0][1] = newStudent();
    array[0][2] = newStudent();
    array[0][3] = NULL;
    array[0][4] = NULL;
    array[0][5] = newStudent();
    array[0][6] = newStudent();
    array[0][7] = newStudent();
    array[0][8] = newStudent();
    array[1] = malloc(3 * sizeof *array[1]);
    array[1][0] = newStudent();
    array[1][1] = newStudent();
    array[1][2] = newStudent();
    array[2] = malloc(1 * sizeof *array[2]);
    array[2][0] = newStudent();

The above is approximately equivalent to

    // Java source (could be shortened)
    Student[][] array = new Student[3][];
    array[0] = new Student[9];
    array[0][0] = new Student();
    array[0][1] = new Student();
    array[0][2] = new Student();
    // array[0][3] and array[0][4] already == null
    array[0][5] = new Student();
    array[0][6] = new Student();
    array[0][7] = new Student();
    array[0][8] = new Student();
    array[1] = new Student[3];
    array[1][0] = new Student();
    array[1][1] = new Student();
    array[1][2] = new Student();
    array[2] = new Student[1];
    array[2][0] = new Student();

... where "approximately" covers a multitude of sins.

getsanjay.sharma@gmail.com wrote On 06/12/07 12:09,:

   Your understanding may be right, but I'm still not
quite sure.  Let's try it another way:

    int[] blob = new int[42];

In this snippet, `blob' is the name of a reference variable,
and the reference variable refers to a nameless array object
containing forty-two `int' elements.  We sometimes use the
name `blob' as if it named the array rather than the array
reference: We say "The values in `blob' are all non-negative"
or "There are no duplicate values in `blob'" or things of
that sort.  But that's just a kind of shorthand, a slightly
sloppy but convenient way of speaking.  (I don't disapprove
of the sloppy usage; it's certainly better than saying "The
elements of the nameless array referred to by `blob' are
sorted in non-decreasing order!")

   Sometimes, though, we need to be careful about what's
what.  Every week, it seems, somebody continues the above
snippet with something like

    int[] glob = blob;
    glob[0] += 1;

... and then wonders why the value of blob[0] has changed:
he only changed glob[0], right?  This illustrates a confusion
between the reference variables `blob' and `glob' and the
nameless array they both refer to.

   A couple more points to help cement the idea that `blob'
is not the "name" of the array:

   - Given the snippet and its continuation, why is the
     array named `blob' and not `glob'?

   - If the array is named `blob', what happens to its
     name after `blob = null'?  The array still exists
     and is not garbage (`glob' refers to it), but are
     you going to say its name has changed?

   - In something like

    int[] cat = new int[42];
    int[] dog = new int[17];
    if (moon.phase() == Moon.FULL) {
       int[] tmp = cat;
       cat = dog;
       dog = tmp;
    }

     ... what is the "name" of the 42-element array?

   Yes; this would correspond to something like

    void method() {
       int[][] primMultiArr = new int[][] {
           { 2, 2, 2 },
           { 3, 3, 3 },
           { 4, 4, 4 },
       };
       ...
    }