Is there any reason that a bitmap should not be destroyed? The reason I ask is because I get a crash when I call destroy_bitmap for some bitmaps. The bitmaps in question are loaded from a datafile, and I'm positive that they aren't being used after the destroy_* function has been called. I also have the same problem with some fonts, also loaded from a datafile. Not all the bitmaps loaded from the datafile cause a crash when destroyed, though.

Also, just for reference, in my triple buffering code I do this:

Then all drawing is done to active page. I'm not supposed to call destroy_bitmap for active_page, right?

The most obvious one being... don't laugh... if you have previously destroyed it or never created it in the first place Destroying a non-existent bitmap will usually result in a crash. In your case you might want to make sure your create_video_bitmap calls aren't failing.

It almost always does for me, but I'm not using the very latest version of Allegro.

As far as I know, it has been valid to pass NULL to destroy_bitmap() since forever. What version of Allegro are you using?

What you allocate, you should free as well.

The dat entries of a datafile are freed by unload_datafile(). You did not allocate the memory for those bitmaps, so you should not destroy tham.

Same problem.

If you allocate the object yourself (ie, get it from a function that returns a BITMAP* or a FONT*), then you have to free it. Otherwise you don't. Think of it this way: you don't free Allegro's default font or the screen bitmap either.

Only nescessary if you explicitly call set_gfx_mode() to destroy the screen (assuming that you don't display the mouse on a different surface, which is generally a silly thing to do).

Sure, but this code seg faults every time for me:

pseudo code crap below:

BITMAP *foo;

void some_routine()
{
.
// We never created the bitmap
.
destroy_bitmap(foo);
}

Right now I think I'm using 4.03.

Right, that's what I'm talking about. Guess I was misunderstood earlier in the thread.

It's early. I'm not awake yet. Sue me. Regardless, the advice is valid.

What about bitmap destruction on program exit? I have my bitmaps encapsulated in a Bitmap class (C++) which is destroyed probably after allegro exits. Does allegro destroy its bitmaps automatically on exit?

Then why I can not destroy a bitmap after allegro exits? the program crashes within the destructor of the Bitmap class calling the 'destroy_bitmap' function.

I guess it may be something with allegro cleanup taking place before bitmap destruction. Is there a way to destroy the bitmaps before allegro exits?

it is not quaranteed. I think GCC does that only in debug mode

huh?

As for cleaning up on program exit, I would simply do something like this:

I would stay away from non-pointer global objects that have destructors that free allegro objects. The order of destroying objects is not defined and when allegro itself closes before your allegro objects are freed you are screwed. With global pointers you should have no such problems.

Thinking logically, yes you have to destroy them yourself because you created them.

Yes

[edit]late
but i add this: