Eleganteste Vorgehensweise "verlinken" von Variablen

[hilfe_suchender]

Hi,
ich zermatere mir den Kopf über ein kleines Problem. Vielleicht kann mir jemand von Euch da weiterhelfen:

Ich suche eine einfache und möglichst elegante Möglichkeit Variablen zu "verlinken" sprich:
Man hat mehrere Variablen irgendwo in seinem Programm und registriert die bei einer Klasse, welche sozusagen Zeiger auf die Variablen erstellt. Damit bekommt die Klasse immer mit wenn sich der Originalwert der Variable ändert.

Der Sinn des ganzen ist, dass ich mehrere Zustände von Variablen nach aussen hin per TCPSocket übertragen, aber die eigentliche Verwendung im Programm strikt von der eigentlichen Socket-Übertragung getrennt halten möchte.

Das Problem mit Zeigern ist aber nun, dass man entweder für jeden Datentyp eigene Zeiger deklarieren muss, oder man benutzt void-Zeiger, aber dann weiss man nichts über die Länge der Daten.

Eventuell gibts da auch die Möglichkeit mit Templates was zu machen, oder es gibt ein Entwurfsmuster welches sowas kann, aber mir fällt keine wirklich elegante Lösung zu so etwas ein.

Euch vllt?

[wanted DadOrAlive]

Mit Rohen Zeigern solltest du nicht arbeiten. Für Arrays gibts std::vector und sonst kannst noch Google: observer pattern und Google: polymorphie vererbung anschauen

[hilfe_suchender]

Hi,
an Observer dachte ich auch schon. Allerdings erscheinen mir die Kosten recht hoch. Ich werde sicherlich an die 1000 Variablen haben die zu überwachen sind, das sind im wesentlichen auch nur bool's, char's und int's und nur einen einzigen Observer.

Das ganze soll auch auf einem Embedded System recht schnell laufen, da die Variablen Prozessdaten aus einer Anlage wiederspiegeln.

Wenn ich Observer benutzen will müsste ich ja jede dieser Variablen in eine Klasse packen...

Vielleicht noch andere Ideen?

[helferlein]

du erstellts für deine daten eine klasse, die alle von einer basisklasse
erben. die kannst du dann registrieren.

struct base
{
    virtual const void *GetData() = 0;
    virtual unsinged GetLength() = 0;
};
class stringclass : public base
{
public:
    stringclass(const std::string &pstr) : str(pstr){}
    const void *GetData()
    {
        return str.c_str();
    }
    unsinged GetLength()
    {
        return str.length();
    }
private:
    const std::string &str; // <---- ALS REFERENZ
};

class manager
{
public:
    void update()
    {
        for (unsigned i = 0; i < vars.size(); ++i)
            send(vars[i]->GetData(), vars[i]->GetLength());
    }
private:
    std::vector<base *> vars;
};

natürlich bekommt der manager nicht mit, wenn sich ein wert ändert, aber
das ließe mit proxy-klassen erreichen

edit:

post zu spät gesehen.
sollte aber trotz klassen schnell sein. 1000 variablen sollte jedes gerät
packen.