habe folgendes Problem und zwar geht es um folgenden Code

class A
{
  public:

    A() {x = 1;}

    A* foo()
    {
      return this;  
    }

    int x;

};

class B : public A
{
  public:

    B() {x = 2;}

    int x;
};

int main()
{
  B b;
  cout << b.foo()->x << endl; 

  return 0;
}

Was ich hier gerne hätte ist, dass eine 2 auf der Konsole ausgegeben wird und nicht eine 1.

Was mir jetzt als erste Lösung einfällt ist, die Funtion foo in B einfach mit dem richtigen Rückgabetyp zu überschreiben (auch das "this" würde dann auf das richtige Objekt, nämlich das der aufrufenden Unterklasse B, zeigen)

class A
{
  public:

    A() {x = 1;}

    A* foo()
    {
      return this;  
    }

    int x;

};

class B : public A
{
  public:

    B() {x = 2;}

    B* foo()
    {
      return this;  
    }

    int x;
};

int main()
{
  B b;
  cout << b.foo()->x << endl; 

  return 0;
}

Aber vllt kennt jemand von euch noch eine elegantere Lösung. Kann man irgendwie als Rückgabetyp der Funtion foo in der Klasse A gerade den des aufrufenden Objekts wählen, d.h. wenn ein Objekt der Unterklasse B die Funktion foo ihrer Oberklasse A aufruft, soll der Rückgabewert von "foo" B* sein und "this" soll auch auf B zeigen.

Gruß

Man kann es auch mit CRTP lösen. Vorher sollte man aber nochmal rekapitulieren, ob es im konkreten Fall nicht bessere Lösungen gibt.

Man kann es auch mit CRTP lösen.

Könntest du das mal kurz andeutungsweise demonstrieren? So einen Gedanken hatte ich auch, aber hab keinen Ansatz gefunden.

template<typename fooT>
class A
{
  public:

    A() {x = 1;}

    fooT* foo()
    {
      return dynamic_cast<fooT*>(this);
    }

    int x;

};

class B : public A<B>
{
  public:

    B() {x = 2;}

    B* foo()
    {
      return this;
    }

    int x;
};

Wenn das die Antwort wäre: Schade, dass static_assert/enable_if nicht gehen.

Ansonsten... möglicherweise ist es das was der OP will. Es ist allerdings strenggenommen nicht das wonach er gefragt hat - schliesslich gibt es dabei keine Klasse "A" mehr, nur mehr eine Klasse "A<B>". Wenn wir dann C von B ableiten sind wir wieder wo wir angefangen haben.

class A 
{ 
public: 
    A() { x_ = 1; }

    virtual int& x() { return x_; } 

    int x_;
}; 

class B : public A 
{ 
public: 

    B() { x_ = 2; }

    virtual int& x() { return x_; } 

    int x_;
}; 

int main() 
{ 
   B b; 
   cout << b.x() << endl; 

   return 0; 
}

Meine Überlegung war folgendermaßen: Wäre foo eine freie Funktion(stemplate), dann könnte man es so machen:

template<class T>
T* foo(T& t) {
  return &t;
}

B b;
foo(b)->x

Soweit, so trivial. Geht das ganze auch als Memberfunktion? Nein, obwohl bei nichtvirtuellen Memberfunktionen b.foo() im Grunde nichts anderes als foo(&b) ist, da der Typ, mit dem das Template parametrisiert ist, der Typ des impliziten this-Arguments und damit nicht (syntaktisch) zugänglich ist.

class A { ...
template<class T>
T* foo(/* T* this ??? */)
{
  return static_cast<T*>(this);
}

Irgendwie widerspricht das meinem Schönheitsempfinden