Mit den Komponten mein ich z.B zunächst die (Debug)Konsole, Statesystem, Mediasystem ......
Jetzt habe ich einen IComponentManager erstellt und wollte diese ganzen Sachen eintragen und dachte mir ich erbe einfachh die klasse IComponent bei der Konsole, dem Statesystem .... und Trage diese in eine map ein ( Polymorph -> IComponent* comp = new IConsole() oder so )

Später soll man einfach die Komponenten suchen können wie z.B : IComponentManager::SearchKomponents(char* name) und bekommt halt die Komponente, jedoch kann ich dann nicht die Funktionen von der Konsole, Statesystem... aufrufen, sondern nur die von der Klasse IComponent ( die dann eben virtual sind )

Deshalb geht das ganze nicht und ich weiß halt nicht weiter was ich machen soll.Ich würde dieses Komponentensystem beibehalten , jedoch weiß ich nicht wie.

Danke Leute

Eine mögliche Lösung ist, dass die Komponenten tatsächlich noch ein zusätzliches Interface mit dedizierter Funktionalität bereitstellen (je nach Komponente). Dabei muss dann eine abhängige Komponente dieses Interface kennen und irgendwie erfragen (z.B. dynamic_cast, oder wie bei COM durch QueryInterface(..)).

Eine andere Möglichkeit ist, die Kommunikation zwischen den Komponenten zu standardisieren und auf Primitive Elemente festzulegen. Z.B. durch einen Baum der aus Nodes und Parametern (bool, int, double) besteht. Abstraktionen finden dann in dieser Datenstruktur statt, Logik/Verhalten in den Komponenten.

Natürlich sind beide Ansätze kombinierbar.

Ich kann dan von überall auf die Konsole zugreifen mit z.B IComponentManager::SearchComponent("IConsole")->Write("blah") ...

Zumindest im Moment hört sich das für mich jedenfalls so an, als ob du all deine Probleme nur hast, weil du meinst, um jeden Preis diesen Manager zu brauchen. Vergiss den Manager doch einfach!? Wenn eine Komoponente eine IConsole haben will, dann gib ihr eine...z.B. im Konstruktor...

Please help

struct IComponent
{
  virtual void update() {}
  virtual ~IComponent() = 0;
};

struct Mgr
{
  thread_id run_in_new_thread(IComponent* to_add);
  void add_to_existing_thread(IComponent* to_add, thread_id thread);
};

struct Console : IComponent
{
  /* ... */
};

int main()
{
  Mgr mgr;
  mgr.run_in_new_thread(new Console);
}

bb

Ich weiß langsam echt nicht mehr was ich machen soll.Ich will doch nur diese Komponenten in eine map eintragen und von dem Manager in der Updatefunktion durchlaufen und alle einträge updaten.
Das ist ja wunderbar mit Polymorph zu machen, jedoch kann ich dann keine Funktionen mehr aufrufen .....

Geht das irgendwie anders ??

Hey Leute ich weiß gerde nicht genau weiter, wie ich eine feature "schön" implementieren kann.

Sorry, aber ich würd sagen, du bist noch nicht ansatzweise so weit, irgendwas schön zu implementieren. Du begehst den typischen Anfängerfehler, ohne ein richtiges Konzept anzufangen. Man muss nicht alles bis ins letzte Detail planen, macht auch nur ganz selten Sinn. Aber bevor man sowas angeht, sollte man schon eine gute Vorstellung von dem Gesamtsystem haben. Welche Komponenten es genau gibt, wie sie zusammenspielen, wie Informationen ausgetauscht werden usw. Im Moment ist deine Vorstellung von dem, wie die Software aussehen soll, noch sehr unasgereift. Einfach zu sagen, "ich will sowas wie Komponenten haben" reicht überhaupt nicht.

So sieht das ganze jetzt aus.Ich kann ja auch einfach die instanzen selbst in der Updatmethode updaten, ist aber nicht so schön naja muss wohl sein.

#ifndef ICOMPONENTMANAGER_H_
#define ICOMPONENTMANAGER_H_

#pragma once

#include "engine.h"
#include "GlobalDefine.h"
#include "IComponent.h"
#include "IConsole.h"

#include <stdlib.h>
#include <map>

class IComponentManager
{
public:

	IComponentManager(void);
	~IComponentManager(void);

	IResult Initialize(HINSTANCE hinst);
	IResult Terminate();
	void Update();

	//--------------Console---------------//

	template<typename T>
	inline void Console_LoginVar(std::string const& name, T& ref) { _debugConsole->LoginVar(name,ref); }

	//------------------------------------//

private:

	ISmartPointer<IComponent> _debugConsole;

	std::map<std::string,IComponent*> _mainThread;
	std::map<std::string,IComponent*>::iterator _mainItr;
	std::map<std::string,std::pair<IComponent*,HANDLE>> _externThread;

	void LoginMainThread(std::string s,IComponent* comp);
	void LoginExternThread(std::string s,IComponent* comp);

};

#endif

#include "IComponentManager.h"
#include "IComponent.h"

//------------Thread----------------//

DWORD WINAPI Thread(LPVOID param)
{
	IComponent* temp = (IComponent*)param;
	while( temp->active != false )
	{
		temp->Update();
	}

	return IRESULT_OK;
}

//-----------------------------------//

IComponentManager::IComponentManager() : _debugConsole(new IConsole) {

}

IComponentManager::~IComponentManager() {

}

IResult IComponentManager::Initialize(HINSTANCE hinst)
{

	IResult rs;
	rs = _debugConsole->Initialize();
	LoginExternThread("Console",_debugConsole.get());
	int i = 32;
    Console_LoginVar("i",i);

	return IRESULT_OK;
}

IResult IComponentManager::Terminate()
{
	IResult rs;
	rs = _debugConsole->Terminate();

	return IRESULT_OK;
}

void IComponentManager::Update()
{
	for(_mainItr = _mainThread.begin(); _mainItr != _mainThread.end(); _mainItr++)
	{
		_mainItr->second->Update();
	}

}

void IComponentManager::LoginMainThread(std::string s,IComponent* comp)
{
	_mainThread.insert(std::make_pair<std::string,IComponent*>(s,comp));
}

void IComponentManager::LoginExternThread(std::string s,IComponent* comp)
{
	HANDLE temp_h;
	temp_h = CreateThread(NULL, 0,Thread,comp,NULL,NULL);

	_externThread.insert(std::make_pair(s,std::make_pair(comp,temp_h)));

}

Mein problem ist gelöst.Einfach das object mittels cast -> static_cast<IConsole*>(_debugConsole.get())->.. dann kann man alle Funktionen der ICoonsole Klasse aufrufen

Du machst irgendwas ganz komisches, aber ich versteh immer noch nicht so recht, was. Hier ist ein dynamic_cast auf jeden Fall passender als static_cast.

Das schaut alles noch irgendwie wenig durchdacht aus. Solche Sachen wie HINSTANCE, HANDLE usw. haben in Klassen, die Component oder ComponentManager heißen, überhaupt nichts verloren. Mit Threads auch nicht. Versteh immer noch überhaupt nicht, was du eigentlich willst und was du mit einloggen meinst.
Du gibst die Threads nicht frei. An einigen Stellen übergibst du strings als konstante Referenzen (richtig), aber nicht überall. Deine Namensgebung ist teilweise etwas komisch. Unterstriche in Methodennamen sind ungewöhnlich. Iteratoren sollte man nicht als Membervariablen halten, und in deinem Fall seh ich da zu schon mal gar keinen Grund.

while( temp->active != false )
{
    temp->Update();
}

Ich denke auch, daß du dich mit deinem Vorhaben übernommen hast und eine falsche Vorstellung von dem Gesamtsystem (z.B. dem Thread-Handling) hast.

Bis hier hin funktioniert das eigendlich gang gut

Das sagt jetzt nicht viel aus Es gibt auch Software, die aus Millionen Zeilen Code besteht und auch irgendwie funktioniert. Nur ist sie komplett unwartbar und von vorne bis hinten falsch, sodass sie komplett unflexibel ist und man nichts erweitern/verändern kann. Dann kommt bei jedem kleinen Änderungswunsch, wo man sich denkt, ist in 1-2 Tagen erledigt als Antwort gleich, das geht doch nicht, dazu müssten wir die Hälfte umbauen und das dauert mindestens ein halbes Jahr...

Ohne ein richtig und möglichst komplett durchdachtes Konzept anzufangen kann nur in eine Sackgasse führen, auch wenn es eine Weile zu funktionieren scheint und seinen Zweck erfüllt.