Variablen einer Basisklasse ansprechen

Ryuzaki schrieb:

Gast123 schrieb:

Ah ok merci. Kann ich die Klasse auch irgendwie bekannt machen?

Mir ist keine Möglichkeit bekannt. Ein kurzes this ist doch aber kein Beinbruch, oder?

Ja aber ich will nicht jedes mal einen this-Zeiger benutzen,wenn ich eine Variable aus IFace nehme.

Abgesehen davon würde ich das Design ändern. Warum ist Vector für Variablen von IVector verantwortlich? Macht für mich nicht viel Sinn.

IVector ist bei die Schnittstelle die für die "primitiven" operationen verantwortlich ist(z.B. = oder +) und Vector hat bei mir die "höheren" opertionen "wie z.B. grow() oder moveDown()", ich dacht das wär eine gute Idee, weil ich finde das so die Lesbarkeit erhöht wird.

Meiner Meinung nach kann das alles in eine Klasse.
Vllt. kannst du Algorithmen, die nur Zugriff auf die primitiven Operationen brauchen, als freie Funktion implementieren, um die Kapselung zu erhöhen.

K ich hab jetzt nur noch eine Frage.
Kann man Vector die Klasse IVector irgendwie bekannt machen, so dass ich nicht immer den this-Zeiger benutzen muss?

#include <iostream>

template<typename T>
class base
{
    protected:
        T data;
};

template<typename T>
class derived : public base<T>
{
    using base<T>::data;
    public:
        void foo()
        {
            std::cout << data;
        }
};

int main()
{
    derived<int> d;
    d.foo();
}

Kompiliert bei mir.

Ah ok vielen Dank.

Ich spreche meine Variablen grundsätzlich mit "Sie" an.

Wird es so aber nicht unübersichtlich?

Gibt es noch eine andere möglichkeit die Variablen einer abgeleiteten Klasse anzusprechen? Ich finde das using nicht so schön aussieht, besonders wenn die abgeleitete Klasse mehrere Variablen besitzt.

drakon

Du kannst die Member direkt über den :: - Operator ansprechen. Um an das Beispiel anzuhängen:

template<typename T>
class derived : public base<T>
{
    //using base<T>::data;
    public:
        void foo()
        {
            std::cout << base::data;
        }
};

Hmm ok es scheint wohl keine optimale Lösung zu geben, die eine Änderung der Klasse verhindert.

template<class T>
class IFoo
{
    public:
        T _data;
};

template<class T>
class Foo:public IFoo<T>
{
    using IFoo::_data; //Das wollte ich vermeiden.
    public:
        Foo()
        {
            IFoo::_data; //Das wollte ich auch vermeiden.
            _data; //Dieser Zugriff wär mir am liebsten gewesen.
        }
};

So wie es aussieht muss ich bei dem Compiler Code::Blocks 8.02 immer wenn ich Klassen, die Templates benutzen, ableite, alle Variablen direkt ansprechen. Schade das ich den Compiler nicht sagen kann das diese Variablen in der Klasse IFoo sind.

Dravere

@Gast123,
1. Code::Blocks ist kein Kompiler, sondern eine IDE. Meistens wird dort der GCC als Kompiler verwendet, allerdings kann man mit Code::Blocks ohne grosse Probleme auch andere Kompiler verwenden. Das nur zur Klarstellung.
2. Das Problem hat nichts mit dem Kompiler zu tun, sondern ist so im C++ Standard definiert. Das Problem ist, dass deine Basisklasse abhängig von einem Template Parameter ist. Dabei ist es unmöglich vor der Instanzierung der Templateklasse zu wissen, was für eine Basisklasse hier tatsächlich verwendet wird. Stichwort: Spezialisierung. Daher muss man dem Kompiler explizit mitteilen, dass er am entsprechenden Ort dann suchen soll. Kurzes Beispiel zur Verdeutlichung:

template<typename>
struct Base
{
  int a;
};

template<>
struct Base<int>
{
  // keine Variable.
};

int a; // globale Variable

template<typename T>
struct Derived
  : Base<T> // Was wird hier als Basisklasse genommen? Wir wissen es noch nicht!
{
  void foo()
  {
    std::cout << a << std::endl;
    // Es wird das falsche a verwendet, da wir noch nicht wissen,
    // welche Basisklasse verwendet werden wird. Im externen Scope
    // kann man allerdings bereits suchen, da dieser bekannt ist.
    // Deshalb wir hier das globale a verwendet.

    std::cout << this->a << std::endl;
    // Wir sagen dem Kompiler, dass es ein a in der Klasse geben muss.
    // Wenn dies nicht der Fall ist, wird es bei der Instanzierung der
    // Templateklasse zu einem Fehler kommen.

    std::cout << Base<T>::a << std::endl;
    // Grundsätzlich das gleiche wie oben, nur dass wir hier explizit
    // sagen, wo gesucht werden soll. Das ist übrigens ein wichtiger
    // Unterschied, betrifft vor allem das Aufrufen von Funktionen.
  }
};

3. Dein Design ist sehr fragwürdig. Die Lesbarkeit wird meiner Meinung nach definitiv nicht erhöht. Schon nur, weil du die Variablen nicht private machst. Du veränderst die Variablen direkt aus anderen Klassen heraus. Dadurch wird es völlig unmöglich irgendwelche Annahmen über die Variablen in der Basisklassen zu machen. Membervariablen sollten so gut wie immer private sein.

Grüssli

Dravere schrieb:

@Gast123,
1. Code::Blocks ist kein Kompiler, sondern eine IDE. Meistens wird dort der GCC als Kompiler verwendet, allerdings kann man mit Code::Blocks ohne grosse Probleme auch andere Kompiler verwenden. Das nur zur Klarstellung.

Jo stimmt mein Fehler^^

3. Dein Design ist sehr fragwürdig. Die Lesbarkeit wird meiner Meinung nach definitiv nicht erhöht. Schon nur, weil du die Variablen nicht private machst. Du veränderst die Variablen direkt aus anderen Klassen heraus. Dadurch wird es völlig unmöglich irgendwelche Annahmen über die Variablen in der Basisklassen zu machen. Membervariablen sollten so gut wie immer private sein.

Hmm wahrscheinlich hast du recht, aber ich wollte das trotzdem mal wissen, weil ich dieses Wissen noch in anderen Projekten brauche.

Ok danke