std::string::assign(std::string const&) ()

Account& account = *getContext().account;
account.createCharacter(Professions::Bloodge, *getContext().textures);
Character& character = account.getCharacter(account.getSlot());
character.setName(name); //<------ AQUÍ EL ERROR

class Account
{
public:
    Account();
    void createCharacter(Professions::ID id, const TextureHolder& textures);
    Character& getCharacter(int n);
private:
    std::array<Character*, MAX_CHARACTERS> mCharacters;    //array que contiene punteros a Character, de tamaño MAX_CHARACTERS
    int currentChars;
    int currentSlot;
};

Account::Account()
{
    currentChars = 0;
    currentSlot = -1;

    //Aquí señalo que inicialmente todos los punteros a objetos Character, serán punteros nulos, es decir, una cuenta sin personajes (Characters)
    mCharacters[0] = nullptr;
    mCharacters[1] = nullptr;
    mCharacters[2] = nullptr;
}

void Account::createCharacter(Professions::ID id, const TextureHolder& textures)
{
        //crea un nuevo personaje en un puntero
        std::unique_ptr<Character> newCharacter( new Character(id, textures));

        //hace que el array apunte a este nuevo Character creado, para asi guardar el nuevo personaje en la cuenta
        //currentSlot es el Slot en donde estoy creando el personaje, la función getSlot utilizada arriba devuelve este valor.
        mCharacters[currentSlot] = newCharacter.get();

        ++currentChars;

}

Character& Account::getCharacter(int n)
{
    std::cout << "n = " << n << std::endl;

    // retorna un personaje de la cuenta (retorna una referencia)
    return *mCharacters[n];
}

class Character:
{
    public:
	explicit Character(Professions::ID id, const TextureHolder& textures);
	void setName(std::string& name);
	std::string getName() const;

    private:
        std::string mName;

};

Character::Character(Professions::ID id, const TextureHolder& textures)
{
}

void Character::setName(std::string& name)          //<------- Esta es la función que da el error
{
    std::cout << "setName activada" << std::endl;
    mName = name;                                              //<------- Esta es la linea del error
    std::cout << "Se dio el nombre con exito" << std::endl; //Obviamente esta linea no se imprime en la consola S:
}


std::string Character::getName() const
{
    return mName;
}

|323|error: expected class-name before '(' token
|323|error: expected '{' before '(' token
|324|error: expected constructor, destructor, or type conversion before ',' token
|324|error: expected constructor, destructor, or type conversion before '(' token

class State
{

    public:
        struct Context
        {
            //Constructor
            Context(sf::RenderWindow& window, TextureHolder& textures, FontHolder& fonts, Player& player);
            sf::RenderWindow* window;
            TextureHolder* textures;
            FontHolder* fonts;
            Player* player;
        };

    public:
        State(StateStack& stack, Context context);
        virtual ~State();
    private:
        Context mContext;
};


//Constructor de la estructura Context que está dentro de la clase State
//Este contructor debería guardar referencias (o punteros) a los recursos obtenidos por argumento
State::Context::Context(sf::RenderWindow& window, TextureHolder& textures, FontHolder& fonts, Player& player)
//Lista de inicialización
: State::Context::window(window)                        //Linea 323
, State::Context::textures(textures)                        //Linea 324
, State::Context::fonts(fonts)
, State::Context::player(player)
{

}

State::State(StateStack& stack, State::Context context)
//Lista de inicialización 2, llama al constructor de Contexto
: mContext(State::Context(*(context.window),*(context.textures),*(context.fonts),*(context.player)))
{

}

class MyClass
{
	public:
		void onCommand(const [b]Command[/b]& command, sf::Time dt);
};

struct Command
{
	std::function<void([b]SceneNode[/b]&, sf::Time)> action;
	unsigned int category;
};

|157|error: 'Command' does not name a type|

struct Command;

class MyClase
{
	public:
		void onCommand(const [b]Command[/b]& command, sf::Time dt);
};

struct Command
{
	std::function<void([b]SceneNode[/b]&, sf::Time)> action;
	unsigned int category;
};

void SceneNode::onCommand(const Command& command, sf::Time dt)
{
    [b]command.category;[/b]
}