bastel grad an einem property template. bin aber nicht so recht zufrieden damit.
erst mal bissl code

hmm, komm grad drauf, das der [C/C++] button unter dem 'Nachrichtentext' nicht funktioniert. bei euch auch so ? oder spinnt mein FireFox ?
naja.

// property-header
template <class Class, class T >
class Property
{
	public:
		typedef T (Class::*cb_func)(const T&);

		Property(Class *obj, cb_func func) : host(obj), callback(func) { }
		Property(Class *obj, cb_func func, const Property<Class, T> &p) :
												  host(obj), callback(func), val(p.val) { }
		Property(Class *obj, cb_func func, const T &v) : host(obj),
												  callback(func), val(v) { }
		~Property(void) { }

		operator const T&(void) { return val; }
		const Property<Class, T>& operator=(const T &v)
		{
			val = (host->*callback)(v);
			return *this;
		}

		const Property<Class, T>& operator=(const Property<Class, T> &v)
		{
			val = (host->*callback)(v.val);
			return *this;
		}

		void SetCallback(cb_func t_func) { callback = t_func; }

	private:
		T val;
		Class *host;
		cb_func callback;
};

// ein test
__fastcall TFMain::TFMain(TComponent* Owner): TForm(Owner)
{
	Property<TFMain, int> x(this, &TFMain::OnChangeValue); // (1)
	x = 45;
	ShowMessage((int)x);
	x = 55;
	ShowMessage((int)x);
	x.SetCallback(&TFMain::OnChangingValue);
	x = x;
	ShowMessage((int)x);
}

int TFMain::OnChangeValue(const int &x)
{
	return x > 50 ? 50 : x;
}

int TFMain::OnChangingValue(const int &x)
{
	return x > 30 ? 30 : x;
}

erstmals gefaellt mir die zeile (1) nicht. kann man das vielleicht vereinfachen?
bei

Property<TFMain, int> x(this, &TFMain::OnChangeValue);

hab ich doch irgendwie 3 mal die selbe info drinnen.
erstmals das der template-parameter 'Class' ein TFMain ist, dann das der erste parameter des konstruktors ein pointer drauf ist und das die uebergebene methode zu TFMain gehoert.
fein waere es wenn mann vielleicht aehnliches wie folgendes machen koennte:

Property<int> x(this, &OnChangeValue);

was haettet ihr fuer aenderungsvorschlaege, favon abgesehen, das es schon fertige property klassen im netz gibt. soll fuer mich eher einen lerneffekt haben.

Meep Meep

Property<int> x(this, &OnChangeValue);

Nö, so wie es bereits ist, ist es korrekt! Hier hast du zu wenig Informationen.

grüße

Property<int> x(boost::bind(&TFMain::OnChangeValue, this, _1));

Der grösste Vorteil dabei ist dass es immer ein Property<int> ist, egal was für eine Callback Funktion drangebunden ist. So wie du es machst wären Property<Foo, int> und Property<Bar, int> 2 komplett unverwandte Klassen die auch nicht interagieren können bzw. auch nicht gegeneinander ausgetauscht werden können (es sei denn natürlich du schreibst extra Code dafür).

eine abhaengigkeit zu boost wollte ich ansich nicht schaffen. hab innerlich eine abneigung gegen boost. woher die kommt, weiß ich bis heute noch nicht. aber die funktionalitaet deiner beschreibung klingt recht interessant. werde mir mal den source angucken, vielleicht kann ich da was fuer meine klasse verwenden.
schließlich

Meep Meep schrieb:

soll fuer mich eher einen lerneffekt haben.

Meep Meep

...

...
		const Property<Class, T>& operator=(const T &v)
		{
			val = (host->*callback)(v);
			return *this;
		}

		const Property<Class, T>& operator=(const Property<Class, T> &v)
		{
			val = (host->*callback)(v.val);
			return *this;
		}
...

Vielleicht ist das ja üblich, aber ich finde diese Semantik etwas verwirrend.
Dass ein "=" einen Funktionsaufruf des gebundenen Objekts durchführt, hätte ich nicht erwartet.
... OK, Du bindest in Deinem Beispiel eine Funktion "OnChangeValue" daran ... aber auch eine Funktion namens "onExternalDeviceInput" würde durch den operator=() ausgeführt werden.

Außerdem hätte ich mir unter "Property" überhaupt keinen "Callback-Funktionstreiber" vorgestellt....

Kann gut sein, dass ich da falsch liege, aber das ist nunmal mein Eindruck.

Gruß,

Simon2.