methodenkapselung

Artchi

Im Prinzip mußt du eine Schnittstelle definieren. Eine Möglichkeit wäre, das sie abstrakt ist und du verschiedene Implementierungen anbietest bzw. jemand anbieten kann. (siehe CStollst Antwort)

Eine andere ist die Verwendung von Adaptern. D.h. eine Klasse definiert ebenfalls eine Schnittstelle, und enthält ein Member mit einer konkreten Klasse. Du kannst dann über den Adapter einfach die Aufrufe weiterleiten, an die Member-Klasse, die der Benutzer so nicht direkt benutzt.

Und dann noch eine Möglichkeit: Context-Pattern. Finde ich immer noch am besten. Leider habe ich da im Netz keine gute Beschreibung gefunden. Das Context-Pattern wird aber in diversen Frameworks eingesetzt, z.B. im ACE. damit kannst du sogar deine Klasse komplett verstecken, also brauchst sie nicht mal in ein Header bekannt geben, weil der Benutzer nur die Context-Klasse zu Gesicht bekommt.

miller_m

es handelt sich grösstenteils um templates somit müsste ich dann wieder irgendwelche "template/virtual hacks" machen (ist gerade kein anderer name eingefallen ) sprich weitere basisklassen und virtuals. ich dachte vielmehr an eine compiletimelösung.
die methode ist auch mehr optional anzusehen einfacher ausgedrückt: das rechteck ist zum rechnen da, nicht zum zeichen.

Warum nicht sowas:

class Rectangle {
private:
    int x,y,...;
public:
    template<class Drawer>
    void draw() {
        Drawer().draw(*this);
    }
};

struct ConsoleTextDrawer {
    void draw(const Rechteck& re) {
        std::cout << "x = " << re.getX() ...
    } 
};

//usage:
Rectangle myrect;
myrect.draw<ConsoleTextDrawer>();

miller_m

Kurz und gut: schrieb:

Warum nicht sowas:

class Rectangle {
private:
    int x,y,...;
public:
    template<class Drawer>
    void draw() {
        Drawer().draw(*this);
    }
};

struct ConsoleTextDrawer {
    void draw(const Rechteck& re) {
        std::cout << "x = " << re.getX() ...
    } 
};

//usage:
Rectangle myrect;
myrect.draw<ConsoleTextDrawer>();

ein haufen getter die die kapselung aufbrechen. gut im falle eines rechtecks wären es maximal vier, das ist aber imo nicht der sinn einer klasse.

Du erstellst ein Rechteck und willst nacher nicht mehr wissen wie gross es ist / wie seine Koordianten etc. sind?
Zu was brauchst du denn diese ganzen Objekte? Ist es nur ein Beispiel mit dem Recheckt oder hast du wirklich geometrische Figuren?

thordk

class Rectangle
{
	// ...
	template<class Functor>
	void foo(Functor &func)
	{
		func(member1, member2, ...);
	}
};

// user
struct myFunc
{
	// haufen eigener funktionen
	myFunc()
	{
		// eigene init aufrufen
	}
	~myFunc()
	{
		// eigene finisher aufrufen
	}
	void operator()(const Typ &t1, const Typ &t2, ...){ ... }
};

myFunc m;
r.foo(m); // Rectangle

miller_m

Kurz und gut: schrieb:

Du erstellst ein Rechteck und willst nacher nicht mehr wissen wie gross es ist / wie seine Koordianten etc. sind?
Zu was brauchst du denn diese ganzen Objekte? Ist es nur ein Beispiel mit dem Recheckt oder hast du wirklich geometrische Figuren?

rechteck war natürlich nur ein beispiel
aber sollte ich die koordinaten wissen wollen?
quick&dirty bsp:

class rect
{
    public:
        rect(int x_, int y_, int w_, int h_)
        : x(x_), y(y_), w(w_), h(h_) { }

        int seitenlänge() const { // ...
        int umfang() const { // ...
        int fläche() const { // ...

        rect& operator += (const rect& src) { // ...

        bool intersects( // ...

    private:
        int x, y, w, h;
};

ich sehe jetzt keinen grund warum ich getX() implementieren sollte

miller_m

@thordk
keine schlechte idee

CStoll

Wenn niemand außen die internen Daten deines Objekts erfahren muß, muß das Objekt auch selber wissen, wie es dargestellt werden will. Also müsstest du den Zeichencode auch in der Rechteck-Klasse unterbringen (eventuell auf Basis einiger abstrakt vorgegebenen Grundoperationen):

class drawer
{
public:
  virtual void draw_line(int x1,int y1,int x2,int y2) = 0;
  ...
};

class DX_drawer : public drawer
{
public:
  virtual void draw_line(...) {/*zeichne Linie mit DX*/}
  ...
};

//...

class gobject
{
public:
  virtual void draw(drawer& target)=0;
}

class rectangle : public gobject
{
  int y,x,w,h;
public:
  ...
  virtual void draw(drawer& target)
  {
    target.draw_line(x,y,x+w,y);
    target.draw_line(x+w,y,x+w,y+h);
    target.draw_line(x+w,y+h,x,y+h);
    target.draw_line(x,y+h,x,y);
  }
};

...
DX_drawer the_drawer;

rectangle r;
r.draw(the_drawer);

miller_m

CStoll schrieb:

Wenn niemand außen die internen Daten deines Objekts erfahren muß, muß das Objekt auch selber wissen, wie es dargestellt werden will.

jein, was wäre wenn der user linksrum statt rechtsrum zeichnen möchte oder sein rechteck aus zwei dreiecken erstellen will usw usw
ich hoffe ich fange jetzt nicht an zu nerven ich suche ja nur nach ideen und lösungsansätzen. vermutlich werde ich aber in die policy geschichte gehen.
dank euch allen