Variablen einer Basisklasse ansprechen

theta

So, und was für eine Fehlermeldung erhälst Du? Und was für ein Compiler verwendest Du?

Edit: Und wie sieht der Code aus, der Foo benutzt?

Simon

Oh natürlich mein Compiler ist Code::Blocks 8.02 und die Fehlermeldung lautet:
E:\C++\Library\Vector.h|63|error: `_data' was not declared in this scope|

K ich poste mal nen Auszug aus meinen Code.

template<class T>
class IVector
{
    protected:
        T* _data;
        int _size;
        static const int GROW_SIZE=10;
};
template<class T>
class Vector:public IVector<T>
{
    public:
        ~Vector(){delete[] _data;}
};

theta

Mit VS2008 SP1 kompiliert der Code anstandslos.
Simon

_data ist in deinem ersten Beispiel vom Typ T, was bringt da der Versuch _data auf 10 (was ja ein integraler Typ ist) zu setzen?
Und in deinem 2ten Beispiel sollte

delete[] this->_data;

klappen.

Hmm das ist blöd, weis jemand warum es bei Code::Block 8.02 nicht funktioniert?

Schreib einfach this->_data. Der Compiler sucht sonst im globalen Scope nach _data, weil er nicht weiß, mit welchem T Vector tatsächlich instantiiert wird, er kennt also die Klasse, von der abgeleitet wird, noch nicht.

[quote="Orakel-Joe"]_data ist in deinem ersten Beispiel vom Typ T, was bringt da der Versuch _data auf 10 (was ja ein integraler Typ ist) zu setzen?

Ja sry sollte nur ein Beispiel sein.

Ryuzaki schrieb:

Schreib einfach this->_data. Der Compiler sucht sonst im globalen Scope nach _data, weil er nicht weiß, mit welchem T Vector tatsächlich instantiiert wird, er kennt also die Klasse, von der abgeleitet wird, noch nicht.

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

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?
Abgesehen davon würde ich das Design ändern. Warum ist Vector für Variablen von IVector verantwortlich? Macht für mich nicht viel Sinn.

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.