Also folgendes, ich hab eine Basis Klasse GameState:

#pragma once
#include <SFML\Graphics.hpp>

class GameStateManager;

class GameState
{
public:
	GameState();
	~GameState();

	virtual void Init();
	virtual void Update(sf::RenderWindow &window, GameStateManager &game);
	virtual void Render(sf::RenderWindow &window, GameStateManager &game);
	virtual void Cleanup();

	friend bool operator==(GameState const& left, GameState const& right) { return false; };
	friend bool operator==(GameState const& left, int const& ID) {
		if (left.ID == ID)
			return true;

		return false;
	};

protected:
	int ID;
};

Dann hab ich noch mehrere Klassen die von dieser Klasse erben und in einer Klasse GameStateManager möchte ich Objekte dieser Klassen die ja alle die gleich Basis Klasse haben in einer Liste speichern.
Das klappt auch eigentlich aber wenn ich eine der funktionen der Basisklasse aufrufe wird nie die überschriebene Funktion in der erbenden Klasse aufgerufen sondern nur die der Basisklasse.
Kann mir jemand sagen was ich machen muss damit die überschriebene Funktion aufgerufen wird?

LogoState:

#pragma once
#include "GameState.h"

class LogoState :
	public GameState
{
public:
	LogoState();
	~LogoState();

	void Init() override;
	void Update(sf::RenderWindow &window, GameStateManager &game) override;
	void Render(sf::RenderWindow &window, GameStateManager &game) override;
	void Cleanup() override;

};

GameStateManager:

#pragma once

#include <list>
#include <algorithm>
#include <SFML\Graphics.hpp>

#include "GameState.h"

class GameStateManager
{
public:
	GameStateManager(sf::RenderWindow &window);
	~GameStateManager();

	void Init();
	void Update(sf::RenderWindow &window);
	void Render(sf::RenderWindow &window);
	void Cleanup();

	void AddState(GameState state);
	void RemoveState(int ID);
	void EnterState(int ID);
	void Start();

private:
	std::list<GameState> gameStates;
	sf::RenderWindow &window;
	GameState currentState;
};

Gruß Erik

Dann, wie meinst du das mit copy und move verbieten und die Basisklasse abstrakt machen?

Wenn dein Compiler C++11 unterstützt kannst du das hier machen:

class GameState
{
public:
    GameState();
    virtual ~GameState(); //muss auf jedenfall hier hin, wenn du Vererbung/Polymorphie nutzt

	GameState(GameState const&) = delete;
	GameState& operator=(GameState) = delete;

	GameState(GameState&&)= delete;
	GameState& operator=(GameState&&) = delete;
};

Ansonsten:

class GameState
{
public:
    GameState();
    virtual ~GameState(); //muss auf jedenfall hier hin, wenn du Vererbung/Polymorphie nutzt

private:
	GameState(GameState const&);
	GameState& operator=(GameState);

	GameState(GameState&&);
	GameState& operator=(GameState&&);
};

GameState(GameState&&)= delete;
    GameState& operator=(GameState&&) = delete;

Ist nicht nötig. Im zweiten Beispiel genausowenig.

§12.8 Abschnitt 9 und 20 schrieb:

If the definition of a class X does not explicitly declare a move constructor, one will be implicitly declared as defaulted if and only if
— X does not have a user-declared copy constructor
[..]
If the definition of a class X does not explicitly declare a move assignment operator, one will be implicitly declared as defaulted if and only if
— X does not have a user-declared copy constructor

okay also reicht es wenn ich von sf::NonCopyable erbe und im vector / in der liste nen pointer speicher?

Edit:
Aber warum sollte die Klasse NonCopyable sein?

Aber wenn ich vector benutze muss ich doch im v****** die größe festlegen

Nein, musst du nicht.

okay dann nehm ich vector

0_o warum ist "v******" mit * ersetzt worden?

Weil du "Voraus" falsch geschrieben hast.