Don't laugh at the easy looking question before you try out your solution yourself.

A friend of mine made a program that used two char arrays in turns(something like doublebuffering). To swap them he used memcpy. I suggested him to use pointer swapping to speed things up considerably but he told it didn't work. Well, it's true. Code like this doesn't work:

 char state[256];
 char lastState[256];
 char *tmp;

 lastState=state;//error: ISO C++ forbids assignment of arrays
 state=tmp;///usr/katsepolygon/cpp/coop/tehas/src/tehas.cpp:134: error: incompatible types in assignment of `char*' to `char[256]'

It looks allmost perfect(tmp is not of type char[256]) but it doesn't work.

My guess is that it's practically impossible to swap two arrays of this kind. What do you think?

some code that does this would be helpful. Everything I have tried haven't worked

This won't work (and it's illegal):

char state[size];
char lastState[size];
char *temp;

temp = state;
state = lastState;
lastState = temp;

You want this:

char buf1[size];
char buf2[size];
char *handle;
if (some_condition)
  handle = buf1; /* buf1 is the active buffer */
else
  handle = buf2;  /* buf2 is the active buffer */
process_data(handle);

Jorram, that's pretty much the same way I have used things before(the second example). I assumed that it works the same on statically defined arrays too.

If these pointers are const pointers then that makes perfect sense. I wonder why I haven't seen it written in any books or tutorials.

I use statically defined arrays very rearely and almost always use dynamic ones or stl containers. That's why I haven't had such problems before.

Thanks everybody.

They arn't pointers. They are arrays, that pretend to look like pointers.

An array is a block of memory. Using the array name without fully derefencing it will implicitly give you a pointer. Check it:

int array[23][25][24];
array == array[0] == array[0][0] == &array[0][0][0] ==
&array[0][0] == &array[0] == &array;

Its still an array. and is NOT a pointer You can treat it like a pointer in MOST cases, but not all.

Its best not to assume an array is a pointer, it'll just give you problems like these.

the array name is a const pointer to the block of memory.

An implicit pointer, just like:

int var;
&var; // this is implicit
int array[3];
array; // so is this

It's a hard-coded value in the program code.

No. Allegro's line pointer points to the end of the allocated structure. The struct itself doesn't allocate any memory.. Allegro does that itself.

I could have swear that allocating a 0 bytes array was valid as allocating a 1 byte array, based on the fact that malloc(0) returns a valid pointer. Seemly I am wrong, sorry

Jorram, yes. BITMAP *ptr; &ptr give you the hard-coded address of the BITMAP pointer, which is a variable pointer that points to a BITMAP struct.

Actually, that is right. However, you can't dereference anything returned by malloc(0) because the first byte you try to dereference is out of bounds. Allegro's line pointer is a static array of char* pointers.

EDIT: clarrification

I didn't say "pointer" I said "const pointer":P. If you look at all the cases where arrays aren't like pointers you'll find they do act like const pointers.