Compile/link errors, we need them? Also what compiler you are using might be handy ;)

Just a guess... you aren't building a console application or you have a unicode console build (replace main with wmain then).

Looks like it built, since it ran.

33 seconds execution time... did you wait 33 seconds before pressing enter several times? None of the text will probably be printed to the console since you don't flush the output (using cout << endl) perhaps? Put that after you write each line to cout, see if that works.

Looks like you are returning from main with a non-zero value... which sounds like a bug in code::blocks since if you don't return a value from main it should implicitly return 0.

Just try

cout<<"What do you want your hero's name to be?" << endl;

etc.

I think using "\n" doesn't flush the output stream. Using endl definitely does. You don't need std:: before endl since you already had

using namespace std;

Also for the last two couts should i use \n on that or samething?

Meh, it's up to you. Whether you use \n or std::endl, both will print out a new line. The only difference between \n and std::endl is that \n will not flush the buffer, but std::endl will flush the buffer. For little programs like these, it make almost zero difference what you choose. For large scale applications that print out a lot of information, they may prefer using \n because constantly flushing the buffer can slow things down a good amount.

I'm going to guess you aren't quite sure what "flushing the buffer" means, though. When you perform input/output operations, like you're doing here, things are commonly buffered. That is, there's some memory that let's things "build up" before finally dumping them out, kind of like a temporary damn. Let me walk you through it:

std::cout << "Hello world!\n";

"Hello world!\n" is only a few characters (13 to be exact). It can be more efficient if, instead of instantly dumping those 13 characters out to the console, you put those 13 characters in a memory buffer, temporarily storing them until you get more data. Once this memory buffer is full (i.e. you try printing out more data and eventually the memory buffer is full), it dumps all of the stored characters out to the console in one go. If you use std::endl instead of \n, it will force the buffer to dump out its data, meaning it won't wait until it's full.

Like I said, for small applications, this isn't something you should really worry about. But if you've got a large application that outputs a lot of data, you might want to not use std::endl so you can let things build up in the buffer (dumping 1000 characters to the console in one go is more efficient than dumping 10 characters to the console 100 times).

Also, I know you're learning, but I hope you're learning that you should pretty much never be getting input into raw char arrays like that. It's okay for a learning exercise, but don't let it become something that you think is the "right way." There are things like std::string and std::getline, which should be your best friends (someday).

Oh yeah. This site has [ code ][ /code ] (use them without spaces) tags that you can put your code in to get nice, pretty formatting :)