ich glaube mich dunkel zu erinnern, dass man einzelne Member einer abgeleiteten Klasse in der Sichtbarkeit einschränken kann.

class Base
{
  public:
    void do_sth1(){};
    void do_sth2(){};
};

class Derived : public Base
{

};

In diesem Beispiel möchte ich dafür sorgen, dass do_sth2() in Derived nicht zugreifbar ist. Jemand eine Idee? Nach Möglichkeit sollte die Base-Klasse unverändert bleiben.

Thx

class Base
{
public:
   void do_sth1() {}
   void do_sth2() {}
};

class Derived : private Base
{
public:
   using Base::do_sth1;
};

In diesem Beispiel möchte ich dafür sorgen, dass do_sth2() in Derived nicht zugreifbar ist. Jemand eine Idee? Nach Möglichkeit sollte die Base-Klasse unverändert bleiben.

In Derived wirst du auf do_sth2() immer zugreifen können, solang do_sth2() nicht schon in Base als privat deklariert wurde. Die Sichtbarkeit nach aussen kannst du bestimmen, z.B. mit Sebastian Pizer vorschlag (der allerdings die "Ist-Ein" Beziehung von Derived und Base verhindert).

class Base
{
public:
   void do_sth1() {}
   void do_sth2() {}
};

class Derived : public Base
{
private:
   using Base::do_sth2;
};

Im Prinzip ist ja dann dies die Lösung, wenn ich nicht irre.

Hmm...

Derived d;
Base* p = &d;
p->do_sth2();

funktioniert immer noch.

Erklär mal, warum Du public inheritance brauchst und Funktion(en) der Basisklasse vor Zugriff schützen willst. Vielleicht hast Du ja einen guten Grund. Ich sehe keinen.

Gruß,
SP

Derived d;
Base* p = &d;
p->do_sth2();

funktioniert immer noch.
SP

Klar, das funktioniert.

Sebastian Pizer schrieb:

Erklär mal, warum Du public inheritance brauchst und Funktion(en) der Basisklasse vor Zugriff schützen willst. Vielleicht hast Du ja einen guten Grund. Ich sehe keinen.
SP

Es ist so, dass ich an der Base Klasse nichts ändern kann. Die existiert so wie sie ist und wird von verschiedenen Personen genutzt. Also sind Änderungen an Base nicht gewünscht.

Die Methoden, die ich "verstecken" möchte sind set Funktionen. Ich erstelle eine Software, die dem Benutzer Zugriff auf die Daten von Base geben soll, ohne jedoch etwas ändern zu dürfen. Und das ohne viel Aufwand. Das man die umgehen kann ist akzeptabel. Wer das absichtlich macht, der ist am resultierenden Verhalten selber Schuld.
Diese Lösung ist allerdings ein kleines Stück besser, als einfach Zugriff auf Base zu gewähren und zu sagen. Benutzt die set Funktionen nicht.

Gru0

KasF schrieb:

class Base
{
  public:
    void do_sth1(){};
    void do_sth2(){};
};

class BaseWithoutDoSth2 : public Base
{
    private: void do_sth2();
};

class BaseWithAll : public Base
{ };

class Derived : public BaseWithoutDoSth2
{ };

Müsste hierbei nicht das Problem entstehen, dass ich in BaseWithoutDoSth2 nicht mehr auf do_sth2 zugreifen kann.

Nein, du müsstest die Basisklassenversion mit Base::do_sth2() aber explizit angeben.

Wieso willst du hier überhaupt Vererbung einsetzen? Solche starken Abhängigkeiten sollte man sich gut überlegen. Aggregation würde meines Erachtens mehr Sinn machen, da du dann auch das Interface selbst bestimmen könntest.