template<class T>
class IFoo
{
    protected:
        T _data;
        int _size;
};

template<class T>
class Foo:public IFoo<T>
{
    public:
        Foo()
        :_data(10);
        {
            _size=0;
        }
};

Simon

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

Simon

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

delete[] this->_data;

klappen.

Ja sry sollte nur ein Beispiel sein.

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?

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.

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.

Kompiliert bei mir.

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

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.

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

@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