Hello guys. I am attempting to make a game and learn Allegro/C++ as I go. I learned Java in high school and basic C++ last semester in college. I think I understand most concepts, but one I for sure don't understand is memory management because that is something I didn't have to deal with in Java, and that may be what is making my program not work.

I am currently working on the level editor for my game (I haven't started the game yet), and I am having trouble with the TTF addon not working. I can successfully use the addon in my main .cpp file, but it isn't working in a separate class that I have made. It keeps telling me that it failed to initialize the ttf addon.

Here is the code in the main file that creates an instance of the separate class "OpenDialogue", which creates a dialogue box (bitmap) for opening a previously-made level.

isShowingDialog = true;
currWorkPathCSTR = createDirectoryPath(currWorkPathAP, argv[0], "maps");
OpenDialogue oDialog (argv[0], "Open a Map", currWorkPathCSTR, ".dat");

Here is OpenDialogue.h:

And here is some of the code from OpenDialogue.cpp:

Basically, at line 9 in OpenDialogue.cpp, it says that it failed to load the TTF addon (and it may fail at loading the main font addon, but I don't know since that one doesn't have a return). That causes the game to crash (as expected because dialogueFont is NULL) at line 74.

At line 64, it also tells me that it failed to create dialogueFont (as expected, because the TTF addon wasn't initialized).

Am I missing something obvious? I'm not sure if I even have to initialize the addons in every file or not.

Disclaimer: I am both intoxicated and too tired to bother reading through your OP.

"Class file" sounds like a Java influence. You must try to understand that C++ is very different from Java. C (the language that Allegro is written in) is even more different.

A file doesn't mean fuck all to C or C++. These compilers think in terms of "translation units". There are various stages of C or C++ building that you need to aware of:

1. Preprocessing. The C preprocessor runs, processing directives (e.g., #include; or any line whose first non-whitespace character is a '#'), and effectively transforms the original source file (e.g., .c or .cpp) with them.

2. Compilation. These translation units are effectively preprocessed source files. These are typically translated into object files. Effectively, the object file is a binary interpretation of the translation unit (i.e., preprocessed source file).

3. Linking. The compiled translation units, as well as third-party libraries, are all linked together into some kind of executable output file.

(Think of each step above as a completely separate program)

The important distinction is that in a language like Java all of the available classes are available at once for interpretation and compilation (or at least, it seems practically so). In C or C++ each translation unit (preprocessed source file) only knows about itself (what it declares or defines) and whatever it #includes.

That said, much C or C++ code manipulates global data. In Allegro this is certainly true. Initializing Allegro or one of its addons (assuming you did so correctly) is global to the entire application. You only need to do so once. If it succeeds (see here) then it is considered initialized for the duration of the application (unless you happen to deinitialize it, but those APIs, if exposed at all, are rarely used in Allegro programs).

Glancing at your code I can say that it is wrong to initialize anything in Allegro within an "open dialog" method/function. That should typically not be handled by library routines, but instead by application code. If it is handled by a library routine it should be something more generic. That is to say, you don't need (nor want) to initialize Allegro nor its addons every time you open a dialog. You do it once for the duration of the application.