Problemas de uso de std::for_each

[ShotoReaper]

Aqui el codigo completo:

GameScreen.hpp

Código:

#ifndef GAMESCREEN_H
#define GAMESCREEN_H

#include <string>
#include <list>
#include <iostream>
#include <algorithm>
#include "Component.hpp"

using namespace std;

class Engine;

class GameScreen
{

    public:
        void setEngine(Engine* engine);
        Engine* getEngine(void);

        void setName(const string name);
        string getName(void) const;

        void AddComponent(Component component);
        void RemoveComponent(Component component);

        void LoadGameScreen(void);

        virtual void Draw(void);
        virtual void Update(void);

        // Sobrescribimos el operador == para poder hacer nuestra propia comparacion
        // friend: no pertenece a la clase, pero puede usar sus miembros
        friend bool operator == (const GameScreen &gs1, const GameScreen &gs2) ;
        GameScreen& operator = (const GameScreen &gs) ;

    protected:
        virtual void Load(void);

    private:

        string name;
        Engine* engine;
        std::list<Component> components;
        bool loaded;

        void PutComponentInOrder(Component component);

        void myfunction(Component cpt);
};

struct CompareGS : public std::binary_function < GameScreen, GameScreen, bool>
        {
            bool operator() (const GameScreen& gs1, const GameScreen value) const
            {
                return (gs1 == value);
            }
        };

#endif // GAMESCREEN_H

GameScreen.cpp

Código:

#include "../../include/GameScreen.hpp"

string GameScreen::getName(void) const
{
    return name;
}

void GameScreen::setName(const string n_name)
{
    name == n_name;
}

Engine* GameScreen::getEngine(void)
{
    return engine;
}

void GameScreen::setEngine(Engine* n_engine)
{
    engine = n_engine;
}

void GameScreen::AddComponent(Component n_cpt)
{

}

void GameScreen::RemoveComponent(Component cpt)
{

}

void GameScreen::PutComponentInOrder(Component n_cpt)
{
    // Buscamos el componente. // ESCRIBIR LOS OPERADORES EN COMPONENT '==', '=' Y LA FUNCION CompareCPT()
    list<Component>::iterator result = find_if(
                                          components.begin(),
                                          components.end(),
                                          bind2nd<CompareCPT>(CompareCPT(),n_cpt);
    if(result != components.end())
    {
        components.remove(n_cpt);

        // En C++, para tocar las narices, no se puede iterar asi:
        //list[i]. En su lugar debe hacerse a traves de std::advance
        //y una variable del tipo de list inicializada en el principio.
        Component& c = *components.begin();
        // itera a traves de los componentes en orden hasta encontrar uno
        // con un valor mas alto o igual, y lo insertamos en esa posicion
        register int i = 0;
        for(i = 0; i < components.size(); i++)
        {
            std::advance(c,i);
            //Component actual_c = *c;
            if(c.DrawOrder >= n_cpt.DrawOrder)
                break;
        }
        components.insert(i,n_cpt);

    }
}

void GameScreen::LoadGameScreen(void)
{
    // Si ya hemos cargado el GameScreen, retornamos
    if (loaded)
        return;

    // Pasamos el GameScreen a modo cargado
    loaded = true;

    // Cargamos el GameScreen
    Load();
}

void GameScreen::Update(void)
{

}

void GameScreen::Draw(void)
{
    std::for_each(
                  components.begin(),
                  components.end(),
                  [](Component cpt)
                  {
                      if(cpt.IsVisible)
                        cpt.Draw();
                  }
                  );
}




bool operator == (const GameScreen &gs1, const GameScreen &gs2)
{
    return (
            gs1.getName() == gs2.getName()
            );
};

GameScreen& GameScreen::operator = (const GameScreen &gs)
{
    if (this == &gs)
        return *this;

    name = gs.name;
    engine = gs.engine;
    loaded = gs.loaded;
    components = gs.components;
    return *this;
};