Ich habe eine Methode, welche ein Element aus einem Container-Attribut sucht und zurückgibt. Im Prinzip möchte ich eine const- und eine nicht-const-Version anbieten.

Die Funktionalität ist aber dieselbe. Wie kann ich jetzt die jeweils andere Methode nutzen?

Ich habe probiert, aus der nicht-const-Variante einfach die const-Variante aufzurufen und mit nem const_cast das const zu killen und das dann zurückzuliefern. Führt aber zu Endlosrekursion, auch wenn ich schreibe:
const* element = getElement();
und er damit doch eigentlich die const-Variante von getElement() aufrufen sollte?

Ich hoffe, die Infos reichen und man kann mir bereits so allgemein helfen, wie ich gefragt habe. Sonst liefer ich auch Beispielcode.

Viele Grüße und danke!

Ich habe probiert, aus der nicht-const-Variante einfach die const-Variante aufzurufen und mit nem const_cast das const zu killen und das dann zurückzuliefern. Führt aber zu Endlosrekursion, auch wenn ich schreibe:
const* element = getElement();
und er damit doch eigentlich die const-Variante von getElement() aufrufen sollte?

Er ruft trotzdem die nicht-const Funktion auf, da C++ die passende Funktion nicht anhand der Verwendung des Returnwertes sucht, sondern nur anhand der Parameter (inklusive dem impliziten "this" Parameter).
Da "this" nicht const ist wird die nicht-const Funktion aufgerufen.
So geht's:

const* element = static_cast<T const*>(this)->getElement();

class Foo
{
public:
  search() const { return const intern_search(); }
  search() { return intern_search(); }

private:
  intern_search() const;
};

//oder:
template<class T>
struct StripConst
{
  typedef T Type;
};

template<class T>
struct StripConst<const T>
{
  typedef T Type;
};

Warum nicht andersrum? Die const-Version ruft die non-const-Version auf

So rum ist doch blöd.
Wenn die non-const-Version das Objekt ändert, ändert die const-Version auch das Objekt, ohne das man das merkt.

Michael E. schrieb:

Warum nicht andersrum? Die const-Version ruft die non-const-Version auf

So rum ist doch blöd.
Wenn die non-const-Version das Objekt ändert, ändert die const-Version auch das Objekt, ohne das man das merkt.

idR aendert die non-const Variante das Objekt nicht, sondern gibt ein handle auf einen internen Wert zurueck. Denn wenn die non-const Variante das Objekt aendern wuerde, dann waere es schwer dazu eine passende const Variante zu machen.

Michael E. schrieb:

Warum nicht andersrum? Die const-Version ruft die non-const-Version auf

So rum ist doch blöd.
Wenn die non-const-Version das Objekt ändert, ändert die const-Version auch das Objekt, ohne das man das merkt.

Hab mich vielleicht etwas missverständlich ausgedrückt. intern_search soll ein non-const-Objekt zurückgeben, aber selbst const sein. Diesem non-const-return-Objekt kann man im const-search dann noch ein const spendieren.

@Michael:
Ja, hab dich falsch verstanden. So tritt das Problem natürlich nicht auf.

Hi,

Ich habe eine Methode, welche ein Element aus einem Container-Attribut sucht und zurückgibt. Im Prinzip möchte ich eine const- und eine nicht-const-Version anbieten.

Die Funktionalität ist aber dieselbe. Wie kann ich jetzt die jeweils andere Methode nutzen?

Komt drauf an. Wie sieht denn die Klasse aus? Eventuell könnte man das so machen:

class dings
{
public:
  ...
  string const& zeile(int idx) const;

  string & zeile(int idx)
  {
    dings const& self = this; // <-- das const ist hier wichtig
    return const_cast<string&>(self.zeile(idx));
  }
  ...
private:
  ...
};

@Shade Of Mine: Scherzkeks. Das die non-const-Version das Objekt momentan nicht ändert ist klar.
Aber wenn ich 3 Monate später denke, dass das gut wäre, dann hätte ich gerne 'nen Kompilerfehler, wenn die const-Variante dadurch dann auch das Objekt ändert.

Viel schlimmer. Du hast dann einen Logikfehler. Denn wenn die non-const Variante das Objekt ändert - was soll dann die const Variante machen??

Damit sind die Beiden nicht mehr symmetrisch. Böse böse Sache.

Sowas ist mir deshalb auch noch nie untergekommen.

Nochmal:
Ich hab eine const-Funktion und eine nicht-const-Funktion, die (zur Zeit) beide das selbe machen.
Um Codeverdopplung zu reduzieren, ruft die eine die andere auf.
Und sinnvoll ist nur, dass die non-const die const aufruft.
Ich gebe hier stumpf Meyers ersten Tipp wieder und hab gerade das Gefühl, das es dir nur darum geht kontra zu geben.

Edit: Bzw. hab ich jetzt nichts gelesen, warum es anders herum vorteilhafter wäre.

Irgendwie reden wir wohl aneinander vorbei...

Jep tun wir.
Mein Fehler. Wir meinen eh prinzipiell das gleiche, ich hab dich nur falsch verstanden.

Nur um das kurz zu klären. Es ist korrekt, dass der non-const-getter nichts ändert, sondern nur eine non-const Referenz zurückgeben soll.

Dann nutze ich einfach ne konstante this-Referenz, danke.

Viele Grüße

jetzt bin ich wieder etwas blöd. Wenn ich das hier in die const-Methode stecke:

onst* element = static_cast<T const*>(this)->getElement();

hab ich doch eine Endlosrekursion. Da bleibt das Programm nämlich gerade stecken.

Syntaktisch funktionieren tut aber das:

const ModelNode* ModelNode::FindNode( const std::string& nodeName ) const
	{
		return const_cast<ModelNode*>(this)->FindNode(nodeName);
	}

Sollte tun, oder?