The problem in your example is that there is no memory allocated to receive the string Saxonia. The char* tribe[0] is initialized to... -- it is not initialized at all!

So something like this would work better:

character.tribe[0] = malloc( 256 );strcpy( character.tribe[0], "Saxonia" );

The cause of the problem is (probably) that this is more of C-style programming than of C++ or Object-Oriented programming. To move one step in the right direction, you could provide a constructor for CHARACTER that allocated the memory:

struct Character{	char* name;	Character( const char* _name )	{		name = malloc( strlen( _name ) );		strcpy( name, _name );	}};

This would disallow the wrong behaviour by compiler semantics, i.e. this:

Character character;

would not be allowed and generate a compiler error, while this

Character character( "Saxonia" );

would produce the correct result. This way invalid assignments like in your example simply cannot be constructed.

If you'd consider this, than please use the class-keyword instead of struct.

Good luck; greetz, Illco.

Before going any further with your game I would recommend you learn how to program in C or C++ and perhaps read up on good coding practices before going any further. this would probably solve some of this very problems you are experiencing.

As for your example of "things not working" using malloc in C++ is generally bad (although in some cases it required). A better solution for storing the character information would be to create an enum of the types, then store that enum value in the character class. When the name is needed call a helper function to receive it. This will save memory (and potentially prevent leaks), help with performance, and is cleaner.

i.e.


typedef enum
{
CharacterType_Saxonia = 0,
CharacterType_Angle
} CharacterType;

class Character
{
CharacterType m_myCharacterType;
};

void Character::SetRace(CharacterType ct) { m_myCharacterType=ct; }
CharacterType Character::GetRace(void) { return m_myCharacterType; };


Now you'd be able to compare types of characters without string comparing...If you wanted to get the name of a specific type, you could do something like this:

class Character
{
static char* GetRaceName(CharacterType ct)
{
if (ct == CharacterType_Saxonia)
{
return "Saxonian";
}

return "Unknown"; // Alternatively you could return NULL (if you're going to handle it properly.
}
};

Wherever you need to access the race you simply type Character::GetRaceName (or could be split into a separate function) and it returns the name. Using enums/macros/constants is much easier than string copying text all over the place, saves memory, and is generally considered more efficient. Please let me know if this helps.

I would reccommend reading up on the std::string class. It will *just work* when you assign to it like that - without having to fiddle with memory.

Good luck on your entry :)

Quote:Original post by Simian Man
I would reccommend reading up on the std::string class. It will *just work* when you assign to it like that - without having to fiddle with memory.

Good luck on your entry :)

Agreed. To paraphrase a signature I saw on here once: if you are a beginner and have char* in your code, you have a bug.