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?

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?

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.