«

I found a interesting pointer problem.

What does the pointer mean?
EXTERN short (*blocks)[64];

And what does the malloc mean?
blocks =
(short (*)[64])malloc(count*sizeof(short [64]));

Any suggestions will be appreciated!
Best regards,
Davy

On Tue, 06 Sep 2005 01:40:01 -0700, Davy wrote:

> I found a interesting pointer problem.
>
> What does the pointer mean?
> EXTERN short (*blocks)[64];

EXTERN isn't a standard identifier, it is probably defined as a macro
somewhere expanding to extern or nothing.

blocks is a pointer to an array of 64 shorts.

> And what does the malloc mean?
> blocks =
> (short (*)[64])malloc(count*sizeof(short [64]));

This allocates in effect a 2D array (in fact an array of arrays) of count
* 64 shorts whose elements can be accessed using blocks[a][b]. Assuming
the malloc() call succeeds of course.

Note this is a case where C and C++ have different approaches. In C you
would tend to use the malloc() call without the cast, in C++ you would
tend to use the new operator.

Lawrence

Davy wrote:

> I found a interesting pointer problem.
>
> What does the pointer mean?
> EXTERN short (*blocks)[64];

Assuming EXTERN is just #defined to be the same as extern, it means that a
variable named 'blocks' is declared (not defined) that is a pointer to an
array of 64 short values.

> And what does the malloc mean?
> blocks =
> (short (*)[64])malloc(count*sizeof(short [64]));

It allocates 'count' arrays of 64 short and assigns the address of the first
one to 'blocks'.

Hi,

Thank you for your help!

So the "blocks" is a pointer to a dynamic 2-D array, is it?

I am confused with
" short (*blocks)[64];"
and " short [64] (*blocks);"
and "short *blocks [64];".

What's their difference?

Best regards,
Davy

"Davy" <> wrote in message
news: oups.com
> Hi,
>
> Thank you for your help!
>
> So the "blocks" is a pointer to a dynamic 2-D array, is it?

It is a pointer to a 1 dimensional array of 64 shorts. Of course, it you
allocate several of these, one after the other, and make blocks point to the
first of them, then it is pointing to the first row of a 2D array. blocks[0]
will get row 0, blocks[1] will get the row 1 and so on. blocks[i][j] will
get the (i,j)th element of a 2D array.

>
> I am confused with
> " short (*blocks)[64];"
> and " short [64] (*blocks);"
> and "short *blocks [64];".
>
> What's their difference?

The first has been explained, the second is not valid C++ at all, and the
second is an ordinary array comprising 64 pointers to short.

--
John Carson

Davy wrote:
>
> Hi,
>
> Thank you for your help!
>
> So the "blocks" is a pointer to a dynamic 2-D array, is it?

No. It is a pointer to an 1D array.

>
> I am confused with
> " short (*blocks)[64];"

start at the variable name. Then read to the right until you reach
a ')' or ']'. Continue reading at the left until you hit a '(' or '['
where you continue to the right and so on. (This is called the left/right rule)

blocks blocks is
blocks) oops, stop reading right, continue left
*blocks) blocks is a pointer
(*blocks) oops, stop reading left, continue to the right
(*blocks)[ blocks is a pointer to an array
(*blocks)[64 blocks is a pointer to an array of size 64
(*blocks)[64] oops, stop reading right, continue to the left
short (*blocks)[64] blocks is a pointer to an array of size 64 of short


> and " short [64] (*blocks);"

blocks blocks is
blocks) -> left
*blocks) blocks is a pointer
(*blocks) -> right
(*blocks) nothing on the right, continue left
](*blocks) syntax error, there cannot be a '[' at this position


> and "short *blocks [64];".

blocks blocks is
blocks [ blocks is an array
blocks [64 blocks is an array of size 64
blocks [64] -> right
* blocks [64] blocks is an array of size 64 of pointer
short * blocks [64] blocks is an array of size 64 of pointer to short



So the first one (used in a program) can be used to build up this data structure

blocks
+---------+ +-------+ ----+
| o----------------->| | |
+---------+ +-------+ |
| | |
^ +-------+
| | | 64 short's
| ...
| | | |
| +-------+ |
| | | |
| +-------+ ----+
|
| ^
| |
| Array of short
|
Pointer to Array of short's

While the third one, can be used to build this:


blocks
+--------+ +-----+
| o-------------------------->| |
+--------+ +-----+ +-----+
| o----------------->| |
+--------+ +-----+ +-----+
| o----------------------------->| |
..... +-----+ +-----+
| o-------------------->| |
+--------+ +-----+ +-----+
| o------------------------------->| |
+--------+ +-----+

^
|
An array of pointers, where each pointer points to a short


--
Karl Heinz Buchegger

John Carson wrote:
>
> "Davy" <> wrote in message
> news: oups.com
> > Hi,
> >
> > Thank you for your help!
> >
> > So the "blocks" is a pointer to a dynamic 2-D array, is it?
>
> It is a pointer to a 1 dimensional array of 64 shorts. Of course, it you
> allocate several of these, one after the other, and make blocks point to the
> first of them, then it is pointing to the first row of a 2D array. blocks[0]
> will get row 0, blocks[1] will get the row 1 and so on. blocks[i][j] will
> get the (i,j)th element of a 2D array.

No way. That indexing will not work.

--
Karl Heinz Buchegger

"Karl Heinz Buchegger" <> wrote in message
news:
> John Carson wrote:
>>
>> "Davy" <> wrote in message
>> news: oups.com
>>> Hi,
>>>
>>> Thank you for your help!
>>>
>>> So the "blocks" is a pointer to a dynamic 2-D array, is it?
>>
>> It is a pointer to a 1 dimensional array of 64 shorts. Of course, it
>> you allocate several of these, one after the other, and make blocks
>> point to the first of them, then it is pointing to the first row of
>> a 2D array. blocks[0] will get row 0, blocks[1] will get the row 1
>> and so on. blocks[i][j] will get the (i,j)th element of a 2D array.
>
> No way. That indexing will not work.

Seems to work fine:

#include <iostream>
#include <iomanip>
using namespace std;

int main()
{
const size_t rowcount = 3;
const size_t colcount = 16;

short (*blocks)[colcount];

blocks = (short (*)[colcount])
malloc(rowcount*sizeof(short [colcount]));

for(size_t i=0; i<rowcount; ++i)
{
for(size_t j=0; j<colcount; ++j)
blocks[i][j] = i*100 + j;
}
for(size_t i=0; i<rowcount; ++i)
{
for(size_t j=0; j<colcount; ++j)
cout << setw(3) << blocks[i][j] << ' ';
cout << endl;
}
free(blocks);
}


--
John Carson

Karl Heinz Buchegger wrote:

>> It is a pointer to a 1 dimensional array of 64 shorts. Of course, it you
>> allocate several of these, one after the other, and make blocks point to
>> the first of them, then it is pointing to the first row of a 2D array.
>> blocks[0] will get row 0, blocks[1] will get the row 1 and so on.
>> blocks[i][j] will get the (i,j)th element of a 2D array.
>
> No way. That indexing will not work.

Why not?

John Carson wrote:
>
> "Karl Heinz Buchegger" <> wrote in message
> news:
> > John Carson wrote:
> >>
> >> "Davy" <> wrote in message
> >> news: oups.com
> >>> Hi,
> >>>
> >>> Thank you for your help!
> >>>
> >>> So the "blocks" is a pointer to a dynamic 2-D array, is it?
> >>
> >> It is a pointer to a 1 dimensional array of 64 shorts. Of course, it
> >> you allocate several of these, one after the other, and make blocks
> >> point to the first of them, then it is pointing to the first row of
> >> a 2D array. blocks[0] will get row 0, blocks[1] will get the row 1
> >> and so on. blocks[i][j] will get the (i,j)th element of a 2D array.
> >
> > No way. That indexing will not work.
>
> Seems to work fine:
>

Mea culpa.
Sorry. I read something else in your explanation.


--
Karl Heinz Buchegger