Error in ge

[SuperSonic]

Hi guys

Ok, so in my global code, I've got this:

Code: Select all

int **level;

And then I've got a draw actor event that looks like this:

Code: Select all

char *key = GetKeyState();

if(key[49])
{
    level[xmouse][ymouse] = 1;
}

The error I get is:

Draw actor: READ error in invalid memory area

Anyone know how to solve this?

[skydereign]

The problem is because you are trying to access uninitialized memory. It's the same problem trying to use a char* before you set it to something.

Code: Select all

int** level; // this doesn't actually point to anything
int level2[10][10]; // this points to a 2d int array

So you can either allocate the memory with C's memory allocators, or the recommended way, give the array a size.

-Edit
And actually looking at that code you shouldn't do that. xmouse and ymouse are not integer values. You should at least truncate them to be integers. And since you are using that, you know what the max array size is, in your case [view.width][view.height] though you should replace the variables with their literal counterparts.

[SuperSonic]

Ok thank you

But here's the thing. I need to be able to have the size unlimited. So could you explain how to use the memory allocators please?

[skydereign]

It'll never be truly unlimited, and from the sounds of it you don't need it to be. But to allocate memory you can use the malloc/calloc/realloc functions.

Code: Select all

char* string = malloc(255);
// normally string would not point to anything but in this case we are setting string to point to the output of malloc
// malloc returns a chunk of memory size determined by the input
// so currently that char* is the same size as the following
char string2[255];

calloc operates a little differently. It takes a data type size and a number. The size of the type is the size of an int, char, or whatever you are allocating memory for. The number determines the amount you should allocate for.

Code: Select all

char* string = calloc(sizeof(char), 255);
// same as the above lines of code

Now in your case you want to allocate based off some large width and height. You need to allocate each dimension separately (first the height, and then the width).

Code: Select all

int ** level = malloc(sizeof(int)*level_height);
int i;
for(i=0;i<level_height;i++)
{
    level[i]=malloc(sizeof(int)*level_width);
}

Notice though this is just the same thing as predetermining the width and height of the array (but it now has the problem of needing to be freed). One of the benefits to allocating your own memory dynamically is that if you can allocate only the space you need (instead of guessing and allocating a lot more than you need). The other one though is you can use realloc, which allows you to change the size of the pointer you passed it. So, you can change the size of a dynamically allocated array. To use realloc you pass it the pointer you want to change the size of and the new size. If you allocate more space then it will store the contents. I got to go so I'll wrap this up with the following warning. Memory that is allocated dynamically must be freed, otherwise you have a memory leak. So if you use dynamic allocation in a function, you'll have to remember to call free on it.

Code: Select all

void
waste_memory ()
{
    char* test = malloc(255);
    // doesn't free the memory and since the space was not passed out of the function it is lost
}

void
useless ()
{
    char* test = malloc(255);
    free(test); // frees the memory and therefore no memory leak
}

[SuperSonic]

Awsome thanks. I'm gonna study this

And I didn't mean to say "unlimited". I meant that I need it to be bigger than just 256. And I thought that Ge didn't let you create arrays bigger than 256. I dunno but thanks anyways

[skydereign]

You can create potentially much larger arrays (you are thinking about strings). gE's built in strings are size 256, and that means you will have trouble if trying to display an array larger than 256 via text. So you can declare arrays a lot larger as long as you aren't dealing with gE's built in arrays. But, I think Bee-Ant has mentioned problems with too large arrays, so do watch out for that.

[SuperSonic]

Like what problems?

[SuperSonic]

Sorry to bump this up

I have three questions. First, could you please explain exactly what free() does? I kinda get the basic concept but I would rather know all of it^^.Second, how would I use realloc() to change the size of a 2d array?

And third:

But, I think Bee-Ant has mentioned problems with too large arrays, so do watch out for that.

Like what problems?

[skydereign]

I have three questions. First, could you please explain exactly what free() does? I kinda get the basic concept but I would rather know all of it^^.

free frees up allocated memory. So you know how malloc/calloc allocates memory for the user? What it essentially does is reserve a certain amount of space. Now if you keep reserving more and more space, eventually you'll run out of space to use. So, when you are done with the memory (no need for it anymore) you should free it. If you don't, it's a memory leak, and can cause problems for you. C handles things via pointers/addresses. A char* for instance is a pointer to a char in memory. So, when you allocate a block of memory, you need to have away of pointing to the memory (otherwise you have a memory leak).

Code: Select all

char* string = malloc(255);

malloc in that case returns the address of a block of memory (size 255). Now free takes an address and frees the memory it points to. So if you used free(string) it would free the memory that string points to. That means that string now points to memory it shouldn't, so you should set it to point to NULL.

Code: Select all

free(string);
string=NULL;

Second, how would I use realloc() to change the size of a 2d array?

I actually posted something you shouldn't do in my previous explanation. To allocate memory for a 2d int array, what you really are doing is allocating an array of int pointers, and then allocating each of those as int arrays.

Code: Select all

int i;
int a_w = 10;
int a_h = 10;
int ** p;

p = malloc(sizeof(int*)*a_h);
for(i=0;i<a_h;i++)
{
    p[i] = malloc(sizeof(int)*a_w); // allocates each sub array individually
}

The second dimension makes allocating/reallocating/freeing the array a lot more complex. To free the above, you must first free the p[i] arrays, and then free the p array. And to reallocate you must reallocate each p[i] array individually as well as reallocate the p array. This can easily get overwhelming. So, really I would recommend allocating a single dimensioned array, and treat it like a two dimensional array. Then whenever you need to reallocate the array, you allocate a new one, copy over the old values into the new one, and then switch them. Still a bit of work, but overall cleaner than dealing with a 2d array.

And third:

But, I think Bee-Ant has mentioned problems with too large arrays, so do watch out for that.

Like what problems?

Oh yeah. I searched for it but didn't find the actual problem. Though I believe it had to do with crashing the game (could be wrong).

[SuperSonic]

Ok thank you and +1