int luiMain[2];
luiMain[0] = 10;
luiMain[1] = 10;
*(&luiMain[0] + 1) == luiMain[1]
#include <stdio.h>
void main()
{
int *laiMain;
int luiX;
laiMain = malloc(4*5);
laiMain[0] = 1;
laiMain[1] = 5;
laiMain[2] = 10;
laiMain[3] = 15;
laiMain[4] = 20;
for(luiX=0;luiX<=8;luiX++) printf("laiMain[%d]=%d\n", luiX, *(((char *)&laiMain[0]) + luiX));
}
int luiX; laiMain[] = { 1, 5, 10, 15, 20 }; for(luiX = 0; luiX < sizeof(laiMain); luiX++) printf("laiMain[%d]=%.8X\n", luiX, &laiMain[luiX]);Quote:Original post by Anon Mike
They did it that way because if you have a pointer to something it makes no sense for p+1 to point into the middle of it. It also falls out naturally from the syntax for arrays.
Quote:Original post by Thevenin
Array[x+1] == I'm ok with that +1 shifting it the sizeof(element).
Array[x] + 1 == This is ludakris, it should shift it 1 byte, not sizeof(element) [headshake]
&Array[x] + 1Quote:Original post by TheveninCan you please show what you mean in terms of real C++ code with regards to tRGB above. You can't possibly mean a 5-dimensional array!
The need arose because I went and did this...
void *Surface = [int][int][struct loRGB][struct loRGB][struct loRGB]...
The first two ints are the width and height, and the rest (Roughly 250k) are all RGB structs.
Inaddition, instead of calling it a void, I went and called it...
struct tRGB *Surface = [int][int][struct loRGB][struct loRGB][struct loRGB]...
So now its impossible to access the first two ints properly without breaking off of the "Multiple of 3" rule imposed by the automated structure cast.
I work with Hex quite often when cheating on DungeonCrawl, but in the programming environment I've never figured out what 0x means, is that just a symbol representing that the following is in Hex?
typedef struct tRGB_s { int x; int y; // The easiest thing is to just add a level of indirection. // C's unbelievably weak typing also lets you get away with just declaring // an array[1] here, and then over-allocating memory accordingly to create // the struct. struct loRGB* data;} tRGB;tRGB* createTRGB(int x, int y) { tRGB* thing = malloc(sizeof tRGB); if (!thing) return NULL; thing->x = x; thing->y = y; thing->data = malloc(sizeof (struct loRGB) * x * y); if (!thing->data) { free(thing); return NULL; } return thing;}int destroyTRGB(tRGB* target) { if (!target) return -1; free(target->data); // it is an invariant that this won't be NULL. free(target); return 0;}tRGB* cloneTRGB(tRGB* src) { tRGB* result = createTRGB(src->x, src->y); if (!result) return NULL; for (int i = 0; i < src->x * src->y; ++i) { result->data = src->data; } return result;}int assignTRGB(tRGB* src, tRGB* dest) { if (!(src && dest)) return -1; tRGB* other = cloneTRGB(src); if (!other) return -1; dest->x = other->x; dest->y = other->y; free(dest->data); dest->data = other->data; free(other); return 0;}struct tRGB { int x; int y; loRGB* data; tRGB(int x, int y) : x(x), y(y), data(new loRGB[x*y]) {} tRGB(const tRGB& other) x(other.x), y(other.y), data(new loRGB[x*y]) { for (int i = 0; i < x*y; ++i) { data = other.data; } } tRGB& operator=(const tRGB& rhs) { // copy and swap idiom, for exception safety. I used something similar in // the C code. tRGB other(rhs); x = other.x; y = other.y; std::swap(data, other.data); } ~tRGB() { delete[] data; }};Quote:Original post by iMalcIf it's behaviour seems wrong, then you are probably doing something in a bad way. Show some real code so we can show you the way that you should really be doing it.
