You should avoid using memcpy() generally, and rather use dynamic containers like std::list or std::vector, as these are much less error-prone than memcpy'ing things in arrays around yourself.
Basically, these are part of the C++ Standard template library. As most compilers today are C++ compilers, you can use them from C, too, in most cases. These containers, algortihms and iterators in the STL (and in other libs, too, like Boost:: for example) are really handy, as they base on templates and so a generic containers you can use with every data type. They handle memory management for you and keep you away from producing segfaults ;), so all you have to do is use them, which simplifies development a lot a times.
A quick test run with your code doesn't reveal any problems with the memory on either side of Array1 and x, and it looks OK to me [if not a little silly]. What exactly is getting overwritten?
it could be possible. if i remember correctly memmove is one function that handles overlapping boundaries. give memmove a try. though one question i have is (since it's been a while since i've used C...) are multidimensional arrays defined to be contiguous (is &Array[j] + 2 == &Array[j + 1]? i mean if done with new you'd have problems cuz your array size is technically 2, not 202.
short*** Array1 = new (short**)[101];for(i = 0; i < 101; i++) { Array1 = new (short*)[101]; for(j = 0; j < 101; j++) Array[j] = new short[2]; }
[Edited by - yadango on March 12, 2006 11:17:35 AM]
Quote:Original post by yadango it could be possible. if i remember correctly memmove is one function that handles overlapping boundaries. give memmove a try. though one question i have is (since it's been a while since i've used C...) are multidimensional arrays defined to be contiguous (is &Array[j] + 2 == &Array[j + 1]?
Yes, they are defined to be contiguous, although your example is flawed since pointer arithmetic automatically acounts for type sizes. This assumes the array is statically defined...you can't use malloc for obvious reasons. I'm also not sure whether or not row-major or column-major forms are required. I'm not even sure which is used, since I always have to look up what those words mean. That, by the way, was my first guess. That the wrong ordering was being assumed, so bounds weren't adding up the way he thought they would.
The two variables, which are Map.SizeX and Map.SizeY, get overwritten when the loopf1 is 37. If I make x only 201, and memcpy only (201*sizeof(short)), then Array1[loopf1][100][0] gets written to, but Array1[loopf1][100][1] doesn't. So I don't think it's any overflow. Array1 and the Map variables are global, and x is local.
Is there something else I can do that would be just as fast or faster?
