It looks a bit odd to me that the 'update' stuff is inside the if(redraw...) {} block, could you move it outside?

Pete

Questions to consider:

1. Is saveMapB actually in buttonList? (Where you add it, is it possible that you actually add a copy instead?) If it's not in there, then Update() will never be called for it.

2. Your calls to Update() seem to happen after that check for 'clicked'. This isn't necessarily going to cause noticeable problems, but it does mean your clicks will register one update later. It's worth getting into the habit of noticing things like this, since sometimes they do matter.

3. I'm sure Allegro has a rectangle drawing function you could use instead of the mega pixel loop. You might have to look under the primitives add-on or some such. Drawing that many pixels manually can't be good for your performance.

Hope that helps

1. Since you're directly using instances of SaveMapButton (rather than pointers to them), C++ has no choice but to make a copy when you add it to the list. The copy seems to be fully functional, so the call to Draw() will draw what you expect - but when you Update() it, only the copy gets its 'clicked' field set. The variable 'saveMapB' contains the original, whose 'clicked' field is never set. Using pointers could solve your problem.

2. You're right

3. I find it useful to add comments like "//TODO: change this" to the code in cases like this. Some IDEs (such as Eclipse) will highlight that point in the code, because it's programmed to recognise the code "TODO". (You get used to breaking the rules of English grammar after a while.)

By using a pointer instead of passing by value?

Button b;
vector<Button*> buttons;
buttons.push_back(&b);

Passing your rectangle by value is really not a problem you need to solve. Passing a pointer to a rectangle doesn't really gain you much, and it could lead to problems if you modify the rectangle it points to while outside of Button class code.

Pointers are simple. They store the address of another object. You access the data they point to by dereferencing them by using the '->' operator.

typedef struct Test {
   int a;
   double b;
   char c;
};

Test test;
Test* t = &test;
t->a = 1;
t->b = 2.0;
t->c = '3';
assert(test.a == 1);
assert(test.b == 2.0);
assert(test.c == '3');

Suppose you have 'int x;'

To obtain a pointer to that variable, you can write &x. Likewise you can write &someArray[10]. You can use & with anything that you can put on the left of = (I think).

To get back to the item being pointed to (i.e. dereference), you use *x. So you can write *x=2 or (*x)++ to modify the int. (*x++ means *(x++), so be careful. Pointer arithmetic works in increments of the size of the data type, so you can use it to walk arrays if you have a pointer to one of the elements.)

The -> operator can generally be thought of as syntactic sugar, so x->y is a synonym for (*x).y. While this is accurate for C, I think in C++ you can overload the -> operator separately; but it's still useful conceptually.

To declare a pointer variable (or anything more complicated than a primitive/struct/class type), you use the same syntax you would use to dereference your way back to the primitive/struct/class. So if you have a variable x and you want to use *x to get back to the int, you write "int *x;". There are more complicated constructions such as int (*x)[10] or void (*funcptr)() if you ever want them.

When you need to specify a pointer type without a name (such as when parameterising that vector type), you simply do it without the name - e.g. <int *> or <int (*)[10]> or <void (*)()>.

Coming from Java, you'll be used to the garbage collector and the safety of knowing that everything is safely on the heap until you no longer hold any references to it. In C++ you have to be much more careful, and Edgar's snippet above is dangerous. If you make something inside a method without using a pointer, then it will be on the stack and will cease to exist when you return from that method. Don't take a pointer to such an item and store the pointer permanently.

To instantiate an object on the heap and have a pointer to it, you can use 'new', and then it will last - but unlike in Java, it won't be garbage-collected, so you'll have to write 'delete thePointerVariable;' later - unless it's a one-shot allocation that you're happy for the OS to clean up for you on exit.

There is one final feature in C++ that's worth knowing about. If you use & in a declaration (as opposed to an expression), then it has a completely different meaning. So for example if you write "int x;" and then "int &y=x;", then y is a reference. It's like a pointer, but you can only initialise it once, and the initial 'take a pointer' and subsequent 'dereference the pointer' operations all happen automatically. Any attempt to set 'y' (again) will be interpreted as "set the thing that y points to", which in this case is x.

If you're trying to declare a variable x which is a pointer to an int, then the way you do it is to think about how you would use that variable. In order to get the int that it points to, you would write *x. Therefore you also write *x to indicate what x is, i.e. to indicate the fact that it is a pointer to something. (You write 'int *x' to indicate that it's a pointer to an int.)

int (*x)[10] is a pointer to a 10-element array of ints. It's useful if you actually think of it as a pointer to a 2D array, perhaps 10x10 or 20x10. It points to the first 10-element sub-array. You can then write (*x)[3] to get the first sub-array, fourth element; or (*(x+5))[3], etc. I didn't mention before that x[5] and *(x+5) are interchangeable in many cases (although again I think you can overload them separately in C++). Given this fact, you can then write x[5][3].

void (*funcptr)() is a pointer to a function that takes no arguments and returns nothing. First you have to dereference the pointer to get the function, then you add the brackets in order to call it. That said, it's more of a convention than a real phenomenon, and C and C++ both let you take a pointer to the function with or without the &, and call it with or without the *.

Doing a 'new' and getting an object involves "allocating" memory from the heap. By one-shot, I mean it's something you do once in your whole program and never do again. You can get away without explicitly deleting it (freeing the memory) because it will happen anyway when you exit. If you're allocating things repeatedly, then you have to free them or else you'll run out. That's how memory leaks happen and is probably the reason so much software becomes slow if it runs too long.