wie kann man in einer C++ klasse properties simulieren ausser mit public members? Optimal wären read only member.

Vermutlich kann man es nur mit GetMethoden regeln.
GetVar1()
GetVar2()

Sehr ärgerlich ...

Aber gibt ne etwas dreckige Methode um das hinzubiegen: Deklarier deine Variablen als const und public. Intern in deinem Klassencode castest du den Variablen für ihre Benutzung das const weg...
Musste halt nur ausreichend testen... Aber dann kann jeder Read-Only auf deine Vars zugreifen (solange der Nutzer nicht auch castet :D)

Hi,

wie kann man in einer C++ klasse properties simulieren ausser mit public members? Optimal wären read only member.

Vermutlich kann man es nur mit GetMethoden regeln.
GetVar1()
GetVar2()

Sehr ärgerlich ...

Es ist lediglich ein wenig umständlicher aber nicht sehr ärgerlich. Das ist aber genau die Methode, wie man read-only-member macht. Ich mache meine Member-Variablen grundsätzlich private und implementiere getter- und setter-Methoden nach Bedarf. Etwa so:

class MyClass
{
    int a; // diese soll von aussen nur lesbar sein
    int b; // dies soll eine öffentliche Property sein
  public:
    int getA() const  { return a; }
    int getB() const  { return b; }
    void setB(int value)  { b = value; }
};

Ich finde es persönlich lesbarer und klarer als so ein Property-template. Das Tamplate (aus http://www.codeguru.com/cpp/cpp/cpp_mfc/article.php/c4031/) ist zwar trickreich und sieht gut aus, aber es fördert meiner Meinung nach nicht die Lesbarkeit und Einfachheit des Codes.

#ifndef PROPERTY_H
#define PROPERTY_H

template<typename T> class property_wrapper
{
public:
	explicit property_wrapper(const T& t)
		: _t(t)
	{}

	operator T() const { return _t; }

private:
	const T& _t;
};

template<typename T> class property_readonly
{
public:
	property_readonly()
	{}
	property_readonly(const T& t)
		: _t(t)
	{}

	const T& get() const { return _t; }

	const T& operator () () const { return _t; }

	operator T() const { return _t; }

	T& operator = (const property_wrapper<T>& t) { return _t = t; }

protected:
	void set(const T& t) { _t = t; }

	const T& operator = (const T& t) { _t = t; return t; }
	const T& operator ()(const T& t) { _t = t; return t; }

	const T& operator += (const T& t) { _t += t; return _t; }
	const T& operator -= (const T& t) { _t -= t; return _t; }

private:
	T _t;
};

template<typename T> class property
{
public:
	property()
	{}
	property(const T& t)
		: _t(t)
	{}

	const T& get() const { return _t; }
	void set(const T& t) { _t = t; }

	const T& operator = (const T& t) { _t = t; return t; }
	const T& operator += (const T& t) { _t += t; return _t; }
	const T& operator -= (const T& t) { _t -= t; return _t; }

	const T& operator () () const { return _t; }
	const T& operator () (const T& t) { _t = t; return t; }

	operator T() const { return _t; }

private:
	T _t;
};

#endif

Diese Template-Klasse kapselt einfach einen Datenwert und liefert entsprechende Operatoren dafür mit.

Benutzung dann z.B. folgendermaßen (Auszug aus einem kleinen Spiel von mir):

class Player
{
public:
  typedef property_readonly<int> INT;
  typedef property_readonly<bool> BOOL;

  INT Gold;
  INT Ritter;
  INT Proviant;

  BOOL Drachenschwert;
  BOOL Pegasus;

  BOOL Kundschafter;
  BOOL Wunderheiler;
  BOOL Koloss;
}

Von außen sind dies dann alles read-only Properties, aber in meiner Klassendefinition kann ich dann mittels des 'property_wrapper' die Werte dann doch verändern (entspricht also dem const_cast).

Und demnächst gibt es dann hier noch die fortschrittlichere Variante mit eigener Set-Methode... (wenn Interesse daran besteht -)