Do I have to call al_destroy_bitmap every time I do this:

img1 = img2

When ever I do it increases my memory usage everytime I do that unless I call that on it. And when I do use it, it crashes but it isn't empty.

If img1 is an ALLEGRO_BITMAP, that creates a leak, so yes, you want to call al_destroy_bitmap on img1. But you have to make sure you don't call al_destroy_bitmap on the same address twice. Also note, al_destroy_bitmap does not set the variable you pass to it to 0 or NULL. If you want that, you have to set it yourself.

Oh I didn't know that. I'll give it a shot.

EDIT: Its still crashing.

1. image is null
2. assign image to image
3. destroy it(if image != NULL) - crashes here
4. make it null
5. assign another image to image

Every ALLEGRO_BITMAP* you create, you should destroy. It doesn't matter how or when you assign it to another pointer as long as you don't lose a reference to a created bitmap before you destroy it.

Ex:

So how to do I make it not crash? I always destroy a bitmap when I assign it if its not null.

I'm probably missing something here, but you don't want to destroy it until you're done displaying it or whatever.

When I monitor my programs memory usage, everytime I reassign an ALLEGRO_BITMAP my memory usage goes up. So I destroy the bitmap before I reassign it, but sometimes it crashes and I don't know why.

When you destroy a bitmap, the memory becomes available for other uses. When it doesn't crash, it hasn't been reused and overwritten to something else yet.

Don't destroy the bitmaps until you are done using them, and only do it once. This crap about memory use going up when you assign a pointer is ridiculous. Assigning a pointer takes exactly zero memory to perform. Whatever you're using to measure your memory use is not accurate.

Post the code.

I'm getting complete random crashes when I go to draw the image sometimes without an errors going off.

I meant all of the code, or at least a complete program that reproduces the issue. The more I speculate on what is going on here the more wrong I become.

The program is like 5000 lines though.... I could attach it if you want to see it. I hate when errors like this happen because my memory isn't increasing anymore but the bitmap is becoming invalid or something and it randomly crashes on draw.

Is the program single-threaded?
Can we see the draw function?

Try searching for imgBuffer in all your code, and make sure you're not accidentally destroying it somewhere or setting it to NULL.

ImgBuffer isn't being drawn at all its just to hold the bitmap that al_load_bimtap_f loads because if I just return al_load_bitmap_f my memory usage goes up everytime(I think not using imgBuffer stops the crashing maybe). I'm just confused on what to do. If I used imgBuffer I get Random crashes if I don't i get a memory leak...

When I use bitmaps with Allegro 5, I do the following:

Basically, don't assume, check all return values, set the initial value to NULL, if you destroy a bitmap, even if you plan to reuse it, reset it to NULL, otherwise if you check to see if it failed to load, and it contains the address of the last bitmap still, your check won't be accurate and you'll have problems. This way you know it is NULL unless it loads safely because that is what you set it to.

Edit: I am curious, how do you check for memory leaks? I use CodeBlocks with MinGW, never done that before but want to.

It seems to me that if you assign a new address to a pointer without first freeing up the memory that it is currently pointing to, than you'll create a leak, I think this is what people are talking about.

OK, I see what you're doing now and I'd recommend against it. What you should be doing is passing ownership of that ALLEGRO_BITMAP object back to the caller. What that basically means is that the caller is now responsible for destroying that bitmap when it's done with it (unless it happens to also pass the responsibility along). In any case, your "constructor" or loader function should not be attempting to remember previously loaded bitmaps and release them like that. Do you understand?

Technically all of the create/load functions for BITMAPs return NULL when they fail so you will reset said pointers to NULL in those cases, but if somebody happens to come along and stick 20 lines of code between destroy and load then it might get lost in the clutter. Better safe than sorry, IMO. bam_free from my C utility library accepts a pointer to a pointer. It frees the memory and sets the pointer to zero for you.

Ok I think I get it now. I think I fixed it by integrating the function into the Image class so it works with the bitmap directly instead of just making a bitmap returning it into the image loader function(that returned the bitmap into the load function then assigned the bitmap from the parameter into the classes bitmap). I gets pretty confusing when you try to make everything object oriented and organized sometimes I guess

I find that things get simpler when you start orienting things in an object-like way.

That was something I had considered as well. Having it check to see if it is NULL, and if not, free it first. I always immediately destroy any bitmaps when I am done with them and set them to NULL so it isn't an issue.

I've done this in my own code where I had a temporary bitmap I was using to load in sprite sheets then divide them up into arrays (to avoid 3D filtering problems on tiled games). I just destroy the bitmap and set it to NULL when I am done loading etc... for each set of sprites/tiles on my latest project.

I read that the Allegro functions return NULL, but, like you, I feel safer setting it myself. Just one little line of code for peace of mind.

A better alternative for C++ is using smart pointers i.e., boost::shared_ptr<T>, which will handle the cleanup for you automatically. This is probably something that the OP should look into as well.

That sounds nice. I'm not doing much in C++ yet myself, but I'll try and keep that in mind when I do.

If img1 and img2 are `ALLEGRO_BITMAP*`s, (which I'm guessing they are), then it's important to understand that you are not making a copy of the bitmap image. You are only making a copy of the pointer to the image.

eg.