Vererbung

cooky451

Nexus schrieb:

cooky451 schrieb:

Problem: Ich habe zwei Klassen (foo & bar). Diese haben (fast) identische - statische und nicht statische - Funktionen; viele benöten Konstanten und gerade diese sind für foo und bar unterschiedlich.

Eventuell eine Basisklasse, von denen foo und bar erben? Dann könntest du die Konstante dem Konstruktor der Basisklasse übergeben.

Hm.. also das müsste eigentlich funktionieren.
Manchmal sieht man halt den Wald vor lauter Bäumen nicht Besten Dank!

cooky451

Ehm.. ne das geht wohl doch nicht -.-
Die statischen Methoden der Basisklasse können ja trotzdem nicht auf nicht-statische Variablen zugreifen..

Eisflamme

Ich verstehe nicht, wieso du statische Methoden hast, die auf nicht-statische Attribute zugreifen wollen. Was spricht gegen nicht-statische Methoden?

cooky451

Prinzipiell nichts - wenn ich keine "vernünftige" Lösung finde werden die wohl rausgeschmissen. Allerdings muss man dann zwangsläufig eine Instanz der Klasse erstellen um eine Methode dieser zu nutzen - was an manchen Stellen nicht umbedingt zweckmäßig wäre.

Eisflamme

Was sind das denn für Methoden? Erklär doch Mal Deinen Kontext.

brotbernd

wieso überhaupt klassen?

int Func(int konstanze)
{
	return 1+2+3+konstanze;
}

int Foo()
{
	const int MY_CONST = 5;
	return Func(MY_CONST);
}

int Bar()
{
	const int MY_CONST = 9;
	return Func(MY_CONST);
}

wenn man unbedingt will von mir aus auch mit statischen methoden.

Eisflamme

Mir ist noch was eingefallen, aber irgendwie macht das alles vermutlich komplizierter als nötig:

enum ConstSetType
{
	SET1,
	SET2
};

template<ConstSetType set>
struct ConstSet
{
	static const int c1;
	static const int c2;
};

template<>
struct ConstSet<SET1>
{
	static const int c1 = 5;
	static const int c2 = 10;
};

template<>
struct ConstSet<SET2>
{
	static const int c1 = 8;
	static const int c2 = 13;
};

template<ConstSetType setType = SET1>
class foo
{
protected:
	static ConstSet<setType> constants_;

public:
	virtual void c1() const {std::cout << constants_.c1;}
	virtual void c2() const {std::cout << constants_.c2;}
};

class bar : public foo<SET2>
{

};

// Test
int main()
{
	foo<> x;
	bar y;
	x.c1();
	x.c2();
	y.c1();
	y.c2();
return 0;
}

Nexus

Vielleicht sollten wir auf die genaue Problemstellung warten, bevor wir immer komplexere Ideen haben

cooky451

Gut, nur als Kontext des Kontextes - quasi als Metakontext sollte man wissen dass ich mir der nicht zwangsläufigen Sinnhaftigkeit der ganzen Aktion bewusst bin. Ich mache das nur weil ich mich etwas an C++ gewöhnen möchte und mir nichts wirklich besseres eingefallen ist ;).

Also ich habe zB. eine Klasse die Funktionen für eine Listbox schachteln. (clear, addstring usw.)
Diese Funktionen gibts jetzt einmal statisch (hier muss man ein window handle übergeben) und einmal nicht statisch (hier wird das window handle der Instanz genutzt).
Wenn Du mir jetzt sagst dass ganze ist eh unsinnig es gibt doch die MFC dann hau ich Dich

Edit: Wow - viele Beitrage in 5 Minuten oO^^

brotbernd

Dann ruft die nichtstatische Methode die statische mit seinem Handle auf.

cooky451

Die nicht statische Methode hat kein Handle als Parameter, das ist ja der Sinn

Eisflamme

Nexus:
Laufzeitpolymorphie allein klappt halt nicht für statische Methoden und die virtual-Methoden sind nur ein Beispiel. Die können in dem eigentlich auch nicht-virtual sein, ändert ja nichts. Und ja, ich find das auch overengineered, aber mir fällt sonst auch nichts ein, wenn man sein kaum benanntes Design so behalten möchte...

cooky:
Und wieso soll man überhaupt die Möglichkeit haben über ein Window-Handle, was meinem Verständnis auf einer anderen Abstraktionsebene steht, etwas zu erreichen? Wenn du so eine Schicht aufbaust, würde ich dem Anwender auch gar nicht die Möglichkeit geben, dass er die "normalen" Handles benutzen kann, wo ist denn da der Sinn?

brotbernd

cooky451 schrieb:

Die nicht statische Methode hat kein Handle als Parameter, das ist ja der Sinn

class ListBox
{
public:
  static void Clear(Handle liste)
  { /* ..Implementierung.. */ }

  void Clear()
  {
    Clear(handle_);
  }
private:
  Handle handle_;
};

cooky451

Hm.. mir fällt gerade auf dass ich in der statischen Methode einfach eine Temporäre Instanz erstellen und dann die nicht statische Methode aufrufen könnte oO..

Eisflamme

Welchen Sinn hat das Handle dann?

brotbernd

cooky451 schrieb:

Hm.. mir fällt gerade auf dass ich in der statischen Methode einfach eine Temporäre Instanz erstellen und dann die nicht statische Methode aufrufen könnte oO..

Was ist denn daran besses als andersrum (so wie eben gezeigt)??

cooky451

@Eisflamme
Dass man bei öfter genutzten Fenstern auch eine Instanz der Klasse erstellen kann und das Handle nur einmal setzen muss.

@brotbernd
Dass man die Konstanten nicht als Parameter übergeben muss.
(Das was Du gezeigt hattest war quasi die Ausgangssituation)

Eisflamme

Dass man bei öfter genutzten Fenstern auch eine Instanz der Klasse erstellen kann und das Handle nur einmal setzen muss.

Ja, aber wenn das Handle offensichtlich unwichtig ist, weil die Funktion auch mit einem temporär erzeugten Handle durchgeführt werden kann, was soll das Ganze dann?