unterschied in der signatur - aufruf unklar

habe zwei gleichnamige methoden:

String& myclass:lala()
String myclass:lala() const //die soll die erste aufrufen

Wie rufe ich in der
String myclass:lala() const

nun die andere gleichmaige auf?

"return ((myclass*)this)->lala();"
hat nicht geklappt. Ergab ne Rekursion

SeppJ

Mit einem const_cast:

#include<iostream>

using namespace std;

struct foo
{
  void bar() {cout << "Non-const\n"; }
  void bar() const {cout << "Const\n"; const_cast<foo*>(this)->bar(); }
};

int main()
{
  foo a;
  a.bar();
  const foo b;
  b.bar();
}

Bist du sicher, dass du im const-Fall eine Kopie zurück geben möchtest und keine const string& ?

Bashar

Sollte ein C-Style-Cast auf myClass* nicht einen const_cast beinhalten?

SeppJ

Bashar schrieb:

Sollte ein C-Style-Cast auf myClass* nicht einen const_cast beinhalten?

Eigentlich schon, aber wer weiß schon immer alle Regeln für die C-Style-Casts? Bei meinem Beispiel tut es auch ein C-Cast. Der Threadersteller hat vielleicht was falsch gemacht. Um ihm zu helfen müsste er aber mal den konkreten Code zeigen, der die Rekursion verursacht. Der const_cast ist jedoch so unendlich klarer, den sollte er auf jeden Fall benutzen. Und falls noch ein Fehler im Code ist, wird ihn der Compiler beim const_cast melden, im Gegensatz zum C-Cast.

Kellerautomat

Das sieht mir sehr böse aus. Eine non-const Methode aus einer const-Methode aufzurufen halten ich zumindest für unpraktisch. Solltest du einmal die non-const Methode abändern, sodass sie *this verändert, erhältst du undefiniertes Verhalten. Falls du den Cast nur brauchst, um eine über die andere implementieren zu können, empfehle ich, es genau umgekehrt zu machen. Dadurch würde dich der Compiler daran hindern, sowas zu übersehen.

SeppJ

Kellerautomat schrieb:

Das sieht mir sehr böse aus. Eine non-const Methode aus einer const-Methode aufzurufen halten ich zumindest für unpraktisch. Solltest du einmal die non-const Methode abändern, sodass sie *this verändert, erhältst du undefiniertes Verhalten. Falls du den Cast nur brauchst, um eine über die andere implementieren zu können, empfehle ich, es genau umgekehrt zu machen. Dadurch würde dich der Compiler daran hindern, sowas zu übersehen.

Wenn du über die non-const die const-Methode aufrufst, dann kannst du die non-const-Methode auch gleich weglassen. Denn ein non-const-Objekt darf auch const-Methoden aufrufen. Und speziell in diesem Beispiel wäre dies sehr, sehr böse, da man eine non-const-Referenz auf ein lokales Objekt zurück geben würde.

Kellerautomat

SeppJ schrieb:

Wenn du über die non-const die const-Methode aufrufst, dann kannst du die non-const-Methode auch gleich weglassen.

Ich bin davon ausgegangen, dass die const-Version irgendwas geconstetes zurückgibt, das die non-const Version const_cast-en kann. Ansonsten kann man sich die non-const Version sowieso sparen.

dot

Kellerautomat schrieb:

Das sieht mir sehr böse aus. Eine non-const Methode aus einer const-Methode aufzurufen halten ich zumindest für unpraktisch. Solltest du einmal die non-const Methode abändern, sodass sie *this verändert, erhältst du undefiniertes Verhalten. Falls du den Cast nur brauchst, um eine über die andere implementieren zu können, empfehle ich, es genau umgekehrt zu machen. Dadurch würde dich der Compiler daran hindern, sowas zu übersehen.

Seh ich genauso.