Functionsaufruf wenn Member in Klasse geändert

So, ich habe in den letzten Stunden viel über template und operator überladung gelesen, ja toll schöne Sache, sicherlich mal zu gebarauchen, ich habe auch viel damit rum experimentiert. ABER
Nicht das was ich meine, ich kann nur die Operatoren für Klassen überladen, so habe ich Variablen die einer Klasse entsprechen:

klasse a = test->b;

was ich aber möchte, ist ein Event, also Functionsaufruf wenn eine Variable geändert wird, nicht eine Klasse!
damit folgendes funktioniert:

/* 1 */ int a = 7;
/* 2 */ test->wert = a;                  //event - Function aufrufen
/* 3 */ int b = test->wert;              // ebenso
/* 4 */ if (test->wert == b) /* etc. */  // hier auch (ist ja wie 3)

Klasse nach int casten geht nicht, und soll auch nicht der Sinn sein

- @helium, wenn deine Angabe dem entspricht mit Proxy, wie muß ich das dann machen.
- sollte functor etc. die einfachere Methode sein: was ist das, wie benutze ich sowas?
- wie kann ich nun das genau realisieren?

@Bashar und Jester
wenn ihr wisst wie ich das realisieren kann, bitte ich euch mir zu helfen.
Das mag zwar nicht so toll sein, aber ich lerne immer mehr, wer hätte gedacht das ich heute Überladung und template lerne.
Danke

PS: <vector> ist wirklich nützlich und cool, beschäftige mich gerade nebenbei damit, <map> gefällt mir aber für manch viele Testprog. von mir am besten, bin durch vector drauf gekommen und guck mir beides genauer an.

Man kann per se keinen Code aufrufen lassen, wenn eine Variable eines Basistyps (int, etc.) geaendert wird. Ginge schon, bloss gibt's keinen Compiler dafuer, und keine C++ Spracherweiterung, die das unterstuetzen wuerde.

Du kannst aber folgendes machen:

#include <string>

#include <stdio.h>

typedef std::string String;

template < class T >
class MutiVar {
   public:
   typedef void (*CallbackHook)( MutiVar<T>& var );
   T            obj;
   String       id;
   CallbackHook func;
   MutiVar( const String& _id, CallbackHook _func )
      :   id(_id), func(_func) { } 
   // ...
   MutiVar<T>& operator=( const T& value ) {
      obj = value;
      func( *this );
   }
   // ...
};
// ...
void Y_Callback( MutiVar<int>& var ) {
   printf( "variable %s has been modified to %d\n", var.id.c_str(), var.obj );
}

void func( void ) {
   MutiVar<int>  a( "Variable A", Y_Callback );
   a = 5;
}

In einer Klasse musst Du die Initialisierung der Variable natuerlich im Konstruktor machen.

class F {
   MutiVar<int> a;
   F( void );
};

F::F( void ) : a( "Variable A" ), Y_Callback ) { }

So geht's auf jeden Fall ohne groesseren Aufwand.

Auch wenn's nicht das ist, was Du haben wolltest!

Sooooo Freunde,

ich habe jetzt viel gelernt und meine eigenen Datenvariablen (class) gebastelt, funktioniert super, aber wie Bashar und Jester schon sagten, ist das nicht das tolle und ware und man sollte es auf der traditionalen Art machen, ala Getter und Setter (get_xxx(), set_xxx(value) ), doch ich brauche Ordnung, und für Windows mit seinen Controls verliert man schnell den Überblick, wenn die Eingabehilfe, bzw. Ergänzung z.B. bei der dev-cpp IDE, aufklappt.
Daher das ganze hier. Ich habe mir zu diesem Zweck was anderes einfallen lassen, eine Get Klasse und eine Set Klasse, so das ich alle getter in einer Klasse habe und alle Setter in einer Klasse:
ControlKlasse->Get->Width(), ControlKlasse->Set->Width(123)
Funktioniert auch super, hier mal eine Kurzform aus der Testphase:

#include <windows.h>

#define MYWINMOVE 77701
#define MYSETTEXT 77702
#define MYSETMENU 77703
#define MYSETICON 77704
/* u.s.w. etc. */

class parameter {
    public:
        HWND Handle;
        int Width;
        int Height;
        int Left;
        int Top;
        LPCSTR Caption;        
        void UpdateControll(int type) {
            if (type == MYWINMOVE && Handle) MoveWindow(Handle,Left,Top,Width,Height,true);
            /* u.s.w. etc. */
        }    

};

class getparam {
    private:
        parameter* param;
    public:
        getparam(parameter* p) {param = p;}
        ~getparam() {}
        int Width() {return param->Width;}
};

class setparam {
    private:
        parameter* param;
    public:
        setparam(parameter* p) {param = p;}
        ~setparam() {}
        void Width(int width) {
            param->Width = width;
            param->UpdateControll(MYWINMOVE);
        }
};

class test {
    private:
        parameter* param;
    public:
        getparam* Get;
        setparam* Set;
        test() {
            param = new parameter();
            Get = new getparam(param);
            Set = new setparam(param);
            /* param->Handle = CreateWindow(....... */
        }
        ~test() {
            delete param;
            delete Get;
            delete Set;
        }

};            
//.............
// in WinMain:
test* t = new test();
t->Set->Width(5);
int x = t->Get->Width();
if (x == 5) MessageBox(NULL,"ok 5","info",MB_OK);
t->Set->Width(8);
x = t->Get->Width();
if (x == 8) MessageBox(NULL,"ok 8","info",MB_OK);
// Test alles ok

Was halltet ihr davon?

masterofx32

enno-tyrant schrieb:

[code]
int eingabe;
cout << "Wert eingeben: ";
cin >> eingabe;
test2.(eingabe);

Hmm, was für eine Syntax ist denn das? Ist damit ein impliziter Konstruktoraufruf gemeint und der Punkt nur versehentlich reingerutscht?