schreibgeschützte member oder properties

CPP_coder

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 ...

ronny

es gibt ein paar libs, die das ganze etwas angenehmer emulieren

Badestrand

Vermisse sowas auch, gibts leider nur in C#

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)

net 0

bestimmt kann man auch was mit überladenen operatoren tricksen...

LordJaxom

...oder mit proxyklassen...

THX 1138

Goooogst du hier oder hier

CPP_coder schrieb:

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.

Badestrand

Außerdem macht es die Klasse um einiges größer , was ja nicht unbedingt sofort ersichtlich ist! Deshalb sollte man es nicht generell überall einsetzen... Jedenfalls nicht, wenn dabei die Größe eine Rolle spielt.

Th

Hier mal ein Ansatz von mir selbst (da man bei den beiden Links die Member-Variable und die Getter/Setter noch selbst implementieren muß):

#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 -)