One option is to write/read the strings using the length-content string format, like:

// write
pack_iputw(str.size(), f);
pack_fputs(str.c_str(), f);

// read
pack_igetw(stringLength, f);
char *buffer = new char[stringLength+1];
pack_fread(buffer, stringLength, f);
buffer[stringLength] = '\0';
string sth = buffer;

Of course, you can also store them as zero-delimited, and use something like:

// write
pack_fputs(str.c_str(), f);
pack_putc('\0');

// read
char c;
string buffer = "";
while (c = pack_getc(f))
    buffer += c;

There is no easy built-in way, just wrap one of the above in two functions and use everywhere you need to save/load strings.

Also, to clear some stuff up, concerning the variable-sized string you mention. Actually, std::string is always the same size in memory, just like any other object in C++. The problem stems from the fact that a std::string internally stores a pointer to a character array, which makes no sense after writing it to a file and reading it back from it.

Unfortunately, all packfiles provide is raw input/output, and the fputs/fgets pair. Almost everything works like the functions from stdio, so just look those up if you need reference for pack_xxx. The differences are documented in the Allegro manual.

Actually, there is one pitfall with my code snippets above. Allegro's pack_fputs always saves stuff as UTF-8, which could cause various annoying errors with the code above. If you stick to ASCII you'll be okay, but if you need Unicode or Extended ASCII characters then you'll have to take care of this problem.

pack_fread(theItem.name, stringLen, thePackfile);

This part won't work. Those buffers I used up there were declared for a reason. You try to read literal characters as the std::string object, which is bound to screw things up badly. Std::strings are quite different from char arrays - you can't treat them as such, you have to use appropriate constructors or operators to set the string.

When writing, you can use c_str() to get a C-like character array. However, this can't be used when reading, because the c_str() array is not modifiable.

You can use C++ with allegro, there is nothing stopping you from doing that. You however need to be careful when using strings with allegro and know the limitations of going from a char array to a string and vice versa.

You can always write wrapper functions...
Write the code once, use it many times.

I use my own method that just came natural (and somewhat from working on sockets). I'm not claiming it to be the best, it's just easy for me.

For each item stored in my packfile, I write two chars (that's two bytes) to the beginning. Bytes can store from 0-255. These two bytes represent the size of the following data in bytes. It kind of looks like this:

ctransfer = new char[strlen(ctext) + 2];
ctransfer[0] = strlen(ctext) / 255;
ctransfer[1] = strlen(ctext) % 255;
strcpy(ctransfer+2,ctext);

Then you'd pack_fwrite as normal using the ctransfer. This way, you are storing the size specifically within the file. I wrote a program to convert text files into this format, so I just use notepad to fill in the data and then use the converter to have it stored in a packfile.

It's just what I do.