habe mal wieder ein Problem - ich glaube (hoffe) dass die Lösung auf der Hand liegt aber ich komme nicht drauf

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.
Also zB.:

class foo
{
public:
  static void func1(int blah);
  void func1();
}
void foo::func1(int blah)
{
  // mache etwas mit MY_CONST = 5
}
void foo::func1()
{
  // mache etwas mit MY_CONST = 5
}

class bar
{
public:
  static void func1(int blah);
  void func1();
}
void bar::func1(int blah)
{
  // mache etwas mit MY_CONST = 9
}
void bar::func1()
{
  // mache etwas mit MY_CONST = 9
}

Das Problem ist jetzt dass ich gerne die Funktionen von foo an bar vererben möchte (was ja auch Sinn macht). Aber die Funktionen sollen dann andere Werte nutzen. Nun kann ich diese Werte leider nicht einfach als nicht-statische member festhalten (und dann mit Konstruktor beschreiben) da die statischen Funktionen da ja nicht drauf zugreifen können. Als statische member kann ich das ganze auch nicht festhalten weil die vererbten Funktionen ja auf die member von foo und nicht auf die von bar zugreifen. Wie mache ich das also am besten?

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.

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!

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.

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;
}

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

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?

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_;
};

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

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

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?