Since I cant use string with allegro's text functions am I doing this correctly?

void TEXT::Draw(BITMAP* buffer) {
    char* s;

    s = new char [m_sText.size()+1];
    strcpy (s, m_sText.c_str());

    textprintf_centre_ex(buffer, font, 0, 0, 0, -1, "%s", s);
    
    delete s;

}

Want to make some nice text effects for my menu's and such, thought it would be safer to handle the text I want to display in a string and play with it that way.

Regards,

Tomoso

Sure I tried that first time round and it threw up an error so I decided to find a way around it.

It's working now...

What a waste of a post, thanks for the fast reply though =D

Edit: Negated.

What X-G means is that you can use the result of std::string::c_str(void) directly...

textprintf_centre_ex(buffer, font, 0, 0, 0, -1, "%s", m_sText.c_str());

In other words, the result of std::string::c_str(void) is all you need if the C string won't be modified (in this case, you're just drawing it to a graphical display, so no problem there) and as long as the std::string object won't be modified before you're done with it (this shouldn't be a problem here unless you access m_sText from multiple threads).

Caveat emptor: if you do what bamccaig suggested, and the string contains format specifiers, there will be trouble. For best results if you don't actually want to do formatted output, use textout_centre_ex.

If m_sText is either protected or private, you won't be able to access its text directly, which is probably why you'd have to call that TEXT::Draw() function. Were you trying to access it externally without proper access permissions (such as being a derived class or a friend) or having it a public variable?

%s is a string
%c is a single character

You can loop through each character in the array with the [] operators, so m_sText[0] through m_sText[length-1] and print each character in your sine-wave pattern as you want. Just print each character with the "%c" instead of the "%s".

While I didn't personally notice (I wasn't worried about the Allegro routine being called, only the C string), it seems Tomoso already took care of that possibility by using "%s" as the format string and [effectively] m_sText.c_str() as the parameter.

I didn't technically say anything regarding the use of printf-family routines. Of course, using textout_centre_ex would probably be quite a bit more efficient, but nevertheless I think the above code should effectively result in the same output regardless of the std::string's contents.

char * and char [] are actually very much the same in a lot of ways. Obviously because you used the const modifier on one you wouldn't be able to change the contents (without a cast), but otherwise they are the same most of the time. The exception being that as a variable (not a parameter) the array is stack allocated and the sizeof operator returns the size, in bytes, of the array, not the pointer; whereas the pointer is just a raw memory address that needs to be initialized by allocating memory (i.e., new char[size]), which will also need to be deallocated later (i.e., delete operator), and the sizeof operator always returns the size of the pointer (i.e., typically 4 or 8 bytes). As parameters of a function or method, they are exactly the same AFAIK.

(Untested)

All that said, I don't see anything wrong with using std::string for this and in fact it does save you a little bit of memory management, which is good.

My reasoning is that it's somewhat more clear and to some degree compiler-checked: if I spell it wrong, there's some chance the compiler will complain that NU or NL is undefined, whereas '0' won't be. Of course, I could also accidentally type NULL, which would likely still work, but would be semantically wrong and could confuse someone. Also, at a quick glance, one might mistake NUL for NULL and be equally confused. I supposed lowercase nul is another approach.