Property System

rapso

hat jemand hier erfahrung mit Property systems für c++, oder kennt eine lib die er empfehlen würde?

erfahrungsberichte usw sind natürlich willkommen.

rapso->greets();

rüdiger

eine Library würde mich auch interessieren.

Ich bekomm leider kein vernünftiges System selbst hin. Irgend wo scheitert es immer bzw. bin ich dann doch zu faul (Vererbung, Container etc.)

Walli

Kannst du kurz sagen, was du damit meinst? google spuckt nichts aus und ich würde gerne wissen, ob es das ist, was ich mir darunter vorstelle .

rüdiger

Ich nehm mal an, dass er so etwas meint

class foo {
  struct get_method {
    int operator()(int i) { return i+1; }
  };
  struct set_method {
    void operator()(int i,int &to) { to=i*10; }
  };
public:
  property<int,get_method,set_method> bar;
};

int main() {
  foo baz;
  baz.bar=1;
  std::cout << baz.bar; //Ausgabe 11
}

Ach ja, ein Problem was ich noch gefunden hab, war den Zugriff den Privaten Membern zu erlauben.

rapso

ja so in etwa, und um genau zu sein.

ich möchte mich von außen, über ein interface, an mein programm verbinden können und ein speicherabbild abrufen(und oder setzen), für den gesammten speicher oder teile davon, mit der beschreibung der jeweils darin befindlichen datentypen sowie ihrer namen.

ich bin fast so weit :), der compforwegen fehlt mir noch ne automatische unterscheidung zwischen klassen und primitiven, deswegen hab ich zur zeit zwei makros

PROPYp(int,TestInt);
PROPYc(Foo,TestFoo);

makros vor allem deswegen, weil ich so einfach über ein define das makro gegen ein leeres ersetzen kann. (ich weiß, typunsicher und fehleranfällig, aber so ist es nunmal :D)

rapso->greets();

groovemaster

Ich poste einfach mal meine Klasse

template <class C, class TG, class TS, TG (C::*Get)() const, void (C::*Set)(TS)>
class property
{
private:
	C& instance_;
public:
	operator TG() const
	{
		return (instance_.*Get)();
	}
	property& operator =(TS rhs)
	{
		(instance_.*Set)(rhs);
		return *this;
	}
	property& operator *=(TS rhs)
	{
		(instance_.*Set)((instance_.*Get)() * rhs);
		return *this;
	}
	property& operator /=(TS rhs)
	{
		(instance_.*Set)((instance_.*Get)() / rhs);
		return *this;
	}
	property& operator %=(TS rhs)
	{
		(instance_.*Set)((instance_.*Get)() % rhs);
		return *this;
	}
	property& operator +=(TS rhs)
	{
		(instance_.*Set)((instance_.*Get)() + rhs);
		return *this;
	}
	property& operator -=(TS rhs)
	{
		(instance_.*Set)((instance_.*Get)() - rhs);
		return *this;
	}
private:
	property(const property&);
public:
	property(C& instance)
		: instance_(instance)
	{
	}
	~property()
	{
	}
};

Die Anwendung sieht dann ungefähr so aus

class foo
{
private:
	bar get_position() const
	{
		//...
	}
	void set_position(const bar& source)
	{
		//...
	}
public:
	property<foo, bar, const bar&, &foo::get_position, &foo::set_position> position; 
	foo()
		: position(*this)
	{
	}
	~foo()
	{
	}
};

Natürlich hat das ganze einige Einschränkungen und Restriktionen, an die man sich halten muss. Aber bei meinem momentanen Projekt funktioniert das bisher ganz gut. Wobei ich mir noch unsicher bin, warum die property-Klasse bei meinem Compiler die private Funktionen ausführen kann. Naja, notfalls kann man die auch public machen.
Wer trotzdem Kritik oder Verbesserungsvorschläge hat, nur her damit.

@rapso
Ich hoffe das geht ungefähr in die Richtung, was du wolltest. Wobei ich nicht genau verstehe, wofür du eine Unterscheidung zwischen Klassen und primitiven Typen brauchst.

rüdiger

@groovemaster
Wenn wir es mal weglassen, dass du einige Template Parameter lieber ein wenig eingrenzen solltest, bleiben immer noch folgende Probleme:

*Vererbung bzw. Das man in einer vererbten Klasse das irgend wie beeinflussen können muss
*Klassen intern muss der Zugriff frei sein
*Container brauchen spezielle Behandlung (kann man ja via Template-Spezialisierung machen)

groovemaster

kingruedi schrieb:

*Vererbung bzw. Das man in einer vererbten Klasse das irgend wie beeinflussen können muss

Was meinst du damit? Virtuelle getter/setter?