Thread: Peculiar malloc / command argument question

Why not ask your friend what he was doing?

What's the difference between a pointer to an array and a pointer to the first element of an array? To the computer, nothing. To the compiler, it's a lot.

So my code is creating a pointer to an array with 80 rows. Say the user supplied 10 in the command line argument, he wanted the stack to have 10 rows. malloc would find memory space for 800 bytes, since 10 rows of potentially 80 bytes each would be 800. So then would I create an array of size 10 and point it to the malloc space I just allocated? Something like this?

Code:

int main(int argc, char *argv[])
{
	char (*aa)[80];
    int stackSize;

    stackSize = atoi(argv[1]);

    aa = malloc(stackSize * 80);

    char bb[stackSize];

    aa = bb;
}

I am still confused with the '80' in char (*aa)[80] however. Why does aa even need to be an array if it is just going to be pointing to a 800 byte location of memory?

edit: more thinking...

Code:

char (*aa)[80];
int stackSize;

stackSize = atoi(argv[1]);
// error checking omitted

aa = malloc(stackSize * 80);

char (*bb)[stackSize];

bb = aa;

So if stackSize was 10, then aa would point to a memory location of 800 bytes, bb would be created to point to an array of size 10, and then that array would be pointed to the allocated 800 bytes worth of memory.

I have no idea what your friend is doing either. That almost looks like an array of pointers to functions, returning type char.

Allocating a single chunk is nothing. It's just malloc (rowsize * numrows).

Do you need to access this memory as discreet rows of 80 bytes where each row has it's own pointer? I've seen that done for better memory management when allocating lots of small items individually would create a performance degrading memory fragmentation.


NOTE: when you assign bb to aa using aa = bb, you're assigning the address of bb to aa and losing track of aa's allocation. That's a memory leak.

I'm looking more at your post.

I think what you want is:

char *bb[argv[1]];

or...

numrows = argv[1];
char *bb[numrows];


Then you loop through to assign each row pointer to each 80 byte segment.

Code:

for (i = 0; i < argv[1]; i++)
    bb[i] = &aa[i*rowsize];

I haven't tested this, so while my ideas work, they rarely work the first time. But that seems about right.

> aa = malloc(stacksize * 80);
Have you read the FAQ yet?
So it would be
aa = malloc ( stacksize * sizeof *aa );

It's the dynamic memory equivalent of
char aa[stacksize][80];

> I do not understand why 80 would be in the brackets?
Precedence
char (*aa)[80]; declares aa as a pointer to an array of 80 chars
char *aa[80]; declares aa as an array of 80 pointers to char
The ( ) are needed to associate the array size with the thing being pointed to, rather than the pointer itself.