nested classes

Sunday

hi,

wie greife ich auf eine abstrakte methode definierte methode in einer verschachtelten klasse zu?

template <typename T>
class BaseClass
{
  protected

  public:

    class NestedClass
    {
      public:

        virtual bool operator != (const NestedClass &rhs) = 0;
    };
};

template <typename T>
class DerivedClass : public BaseClass<T>
{
  // ???
  bool NestedClass::operator != (const NestedClass &rhs)
  {
  } 
};

geht sowas ueberhaupt?

Bashar

Du müsstest eine neue innere Klasse erzeugen und diese von der inneren Klasse der Basisklasse ableiten:

class Base {
  protected:
  class InnerBase { ... };
};

class Derived : public Base {
  class InnerDerived : public InnerBase { ... };
};

Das müsste so in etwa funktionieren.

Sunday

kann es sein, dass man operatoren nicht als abstrakt definieren kann?

Bashar

Nein. Es kann sein, dass das nicht sinnvoll ist, aber möglich ist es auf jeden Fall.

HumeSikkins

Hallo,
ich verstehe zwar dein Problem nicht, die Lösung hat Bashar aber bereits genannt:

template <typename T> 
class BaseClass 
{ 
  public: 

    class NestedClass 
    { 
      public: 

        virtual bool operator != (const NestedClass &rhs) = 0; 
    }; 
}; 

template <typename T> 
class DerivedClass : public BaseClass<T> 
{ 
public:
     struct NestedClass : public BaseClass<T>::NestedClass 
     {
         bool operator !=(const typename BaseClass<T>::NestedClass& rhs)
         {
              ...
         }
     };
};

Sunday

ahhh...

bool operator !=(const typename BaseClass<T>::NestedClass& rhs)

ich hatte nur NestedClass statt dem typename BaseClass<T>::NestedClass da stehen.

jetzt funktioniert es...

danke!