ich arbeite seit bedenklicher Zeit an einem GUI System, bis jetzt lief eigentlich alles gut, es gibt eine domain für die Visualisierung, die auf Basis der Fenster Rendergeometrie erstellt und über Directx 11 rendert.

Die Fenster lassen sich polymorphisch von einer grundfensterklasse ableiten und beinhalten wiederum einen Speicher für wiederum polymorphische Controls, die einfach im Konstruktor des Fensters hinzugefügt werden können,insofern kann sich der Benutzer schon ganz gut neue Fenster zusammenstellen.

Nun würde ich gerne ein Graphencontrol erstellen, das funktioniert soweit gut, aber ich suche jetzt nach einer Möglichkeit, wie ich von dem Fenster selber die Daten zu dem Control rüberschleusen kann, unzwar derartig, dass hinter dem Fenster eine beliebige Klasse stehen kann.

Darum kann ich den normalen Syntax von memberpointern nicht verwenden und brauche etwas anderes.

Ich würde mich wirklich freuen, wenn sich jemand finden würde, der mir irgendein sostiges Zeigertool liefern könnte.

Das würde dann aber wieder bedeuten, das der Benutzer nur eine begrenzte Zahl an solchen Kommunikationen zu verfügung hat, jhe nachdem, wieviele Funktionen in der Basisklasse bereitgestellt werden und wie gesagt ich finde diese Lösung sieht sehr unsauber aus

Also, ich habe eine klasse graphcontrol, welches von der basisklasse guielement abgleitet ist und in einer beliebigen polymorphischen Klasse die von der Klasse fenster abgeleitet ist gespeichert wird.

Was ich jetzt machen will ist, dem graphcontrol in irgendeiner Form die Daten einzugeben, die dargestellt werden sollen. Das würde ich aber am liebsten über einen Funktionszeiger machen, der einem wert x den Funktionswert zuordnet und dem control zurückgibt. Das heist ich würde in jeder Fenster Klasse die das Control benutzen will nur eine Funktion implementieren müssen, welche zum Beispiel so aussieht.

float getwert(float x)
{
   return x*x;
}

Dann würde ich dem Control einen Zeiger übergeben, der einfach nur darauf verweist und das Control könnte sich alle Daten einfach rausziehen.

Ich könnte die Daten auch in dem Fenster generieren und dem control übergeben aber das wäre meiner meinung nach für den Benutzer, der seine Daten in dem Control anzeigen will unpraktisch insofern das control intern noch daten hinzufügen würde und die koordinaten noch in Koordinaten innerhalb des Anzeigefeldes umrechnen würde.

Das Problem ist nun, das ich nicht weiß wie ich diesen Zeiger aufbauen soll. Der schwierige Teil daran ist, das das spezifische Fenster ja von der Fensterklasse abgeleitet wird und ich auf eine memberfunktion einer unbekannten Klasse verweisen muss.

Möglichkeit 1: std::function (bzw. boost::function ).
Damit hast du einen Container für beliebige Funktoren.

Mit std::bind (bzw. boost::bind ) kannst du solche Funktoren aus freien Funktionen oder Memberfunktionen beliebiger Klassen erzeugen -- und dabei wenn nötig gleich noch Parameter wie z.B. den impliziten "this" Parameter in die erzeugten Funktoren "hineinbinden".

Möglichkeit 2: definiere eine Interface-Klasse über die das Graph-Control die Daten abfragt. Also so

class IGraphControlDataSource
{
public:
    virtual float GetData(float x) = 0;
};

Die Fensterklasse müsste dann eine kleine Hilfsklasse definieren die von IGraphControlDataSource abgeleitet ist, und die GetData Funktion passend implementiert.
Und das Graph-Control bekommt statt eines Funktionszeigers einen Zeiger auf die Interface-Klasse übergeben.

Sofern es sich nur um eine Funktion handelt würde ich Möglichkeit 1 vorziehen - da wesentlich einfacher in der Anwendung. (Für die Implementierung des Controls macht es keinen Unterschied, für den Anwender des Controls ist es aber viel angenehmer wenn er einfach bind(&Fenster::GetData, this, _1) schreiben kann, statt dauernd Hilfsklassen zu schreiben die dann eh nur aus einer Zeile Code bestehen.)

Sorry Schonmal dafür ich hab bis jetzt alles ohne Funktionspointer und ähnliches geschafft . bind generiert mir also einen Funktionszeiger? Wenn ja, unter welchem typ wird der abgespeichert, im Internet habe ich bis jetzt immer nur die verwendung von bind mit dem auto präfix gesehen.

Wenn Ich den Rückgabewert von bind aber in der controlklasse speichern muss, dann dürfte auto ja nicht funktionieren, also wie speichere ich das irgendwas?

Graphenfenster:

class graphfenster : public fenster
{
    void getwert(float* ret,float x)
    {

    }
    //Muss ich den Objektzeiger in den Parametern mitführen?

    graphfenster()
    {
        Objekt_in_graphgui = bind(&getwert,this,_1,_2);
        //Ich glaube ich verstehe den syntax von bind nicht
    }
}

class fenster
{
	friend class guielement;
protected:
	guielement** controls;

   	XMFLOAT3 position;
 	XMFLOAT2 größe;

	unsigned int controlcount;
	unsigned int controlspeicher;

	XMMATRIX transform;
	XMMATRIX detransform;
	XMMATRIX eigentransform; //transformationsmatrix die das eigentliche fenster einbindet
	XMMATRIX deeigentransform;

	...es folgen unmengen an weiteren Funktionen und überschreibbaren Funktionen die events weiterleiten sowie viele triviale Variablen...
public:
	fenster();
	virtual ~fenster();

	#pragma region Controls verarbeiten
	void addgui(guielement* objekt);
	bool deletegui(unsigned int index);
	bool replacegui(unsigned int index, guielement* objekt);
	#pragma endregion
};

guicontrol:

class graphgui : public guielement
{
	XMFLOAT2 start;
 	XMFLOAT2 größe;

	XMFLOAT3* daten; 
  	unsigned int datencount;
	unsigned int funktionen;

	XMFLOAT3* farben;

        //Wird zum refresh von der Fensterdomain aufgerufen (abstrakte funktion in guielement)
	void getvisual(guielementreturn* einausgabe)
        {
           float* kanäle = new float[funktionen];
           bildpunktschleife:
               Objekt_in_graphgui(kanäle,schleifenposition); //Ich weiß wirklich nicht wie das Funktionsobjekt aussehen soll
               Daten aus kanäle in den geometriespeicher eintragen 
           schleife ende
        } //aus dieser Funktion müsste dann getwert aufgerufen werden
public:
	irgendeintyp Objekt_in_graphgui; 

	float getx() { return start.x; }
	float getbreite() { return größe.x; }
	float gety() { return start.y; }
	float gethöhe() { return größe.y; }

	graphgui(XMFLOAT3 pos, XMFLOAT2 xy2,XMFLOAT2 initialmin, XMFLOAT2 initialmax,unsigned int datenpunkte,unsigned int funktionen,XMFLOAT3* farben,void* set);
	graphgui(XMFLOAT3 pos, XMFLOAT2 xy2,XMFLOAT2 initialmin, XMFLOAT2 initialmax,unsigned int datenpunkte,unsigned int funktionen,void* set);
	~graphgui();
};

Ich wäre dir oder wenns sein muss auch jemandem anderen :p sehr dankbar, wenn er mir mit der implementierung helfen könnte, ich denke nämlich ich habe eine falsche vorstellung von bind.

Im Zweifelsfall bitte auch folgende Hinweise beachten:
C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

Dieses Posting wurde automatisch erzeugt.