Stringklasse,operatorüberladung...arghl

Shade Of Mine

Man.bloed schrieb:

funktionieren nicht!

kleiner tipp: nie eine Fehlerbeschreibung geben, wir lieben ein gutes Rätsel

hab doch schon ganz am anfang gesagt was nich geht:
Operator +:

MeinString str("hallo");
MeinString str2("test");
MeinString str4("hallo");
MeinString str3=str+str2;

da wird nicht nur aus str3 hallotest, sondern auch aus str (aber str soll sich ja nich verändern)

Und equal:
da liefert immer false zurück, ausser wenn ich die gleichen Instanzen vergleiche:
str==str=true;
str==str4=false;

beide haben aber selben inhalt (hallo)

groovemaster

Man.bloed schrieb:

hab doch schon ganz am anfang gesagt was nich geht:
Operator +:
MeinString str("hallo");
MeinString str2("test");
MeinString str4("hallo");
MeinString str3=str+str2;
da wird nicht nur aus str3 hallotest, sondern auch aus str (aber str soll sich ja nich verändern)

Und was erwartest du, wenn du

char* chr1 = strcat(chr,rhs.chr);

schreibst? Ich hoffe dir ist klar, dass du damit die aktuelle Instanz veränderst. Mit const-correctness wäre das übrigens nicht passiert.
Aber um's kurz zu machen, Shade hat ja schon ein Beispiel gepostet, wie das im Prinzip aussieht. Du erstellst eine temporäre Instanz, hängst den rechten Operanden ran und gibst diese by-value zurück. Und mit entsprechendem copy-ctor funktioniert das dann auch problemlos.

const MeinString operator +(const MeinString& lhs, const MeinString& rhs)
{
    MeinString tmp(lhs);
    tmp += rhs;
    return tmp;
}

Fehlt nur noch der entsprechende Assignment-Operator, aber das wirst du schon hinbekommen. Der Funktionsrumpf sieht wie folgt aus

MeinString& operator +=(const MeinString& rhs)
{
    //...
    return *this;
}

Auf diese Art und Weise lassen sich übrigens alle verknüpfenden Operatoren (+,-,*,/,%,&,|,^) implementieren.

edit:
Rückgabewert von operator + korrigiert.

picocat

Shade Of Mine schrieb:

Foo operator+(Foo const& other)
{
  Foo temp(other);
  temp+=*this;
  return temp;
}

Foo operator+(Foo const& a,Foo const& b)
{
  Foo temp(a);
  temp+=b;
  return temp;
}

ok

groovemaster

Shades Beispiel war aber innerhalb der Klasse. Bin mir zwar jetzt nicht ganz sicher, was er wollte (bis auf des fehlende const). Aber er macht in Wirklichkeit b + a, obwohl es a + b sein müsste.

Shade Of Mine

groovemaster schrieb:

Shades Beispiel war aber innerhalb der Klasse. Bin mir zwar jetzt nicht ganz sicher, was er wollte (bis auf des fehlende const). Aber er macht in Wirklichkeit b + a, obwohl es a + b sein müsste.

Ja, ich wollte auf das const hinaus.

das mit b+a war ein Fehler von mir hab nicht genau nachgedacht und nach sturer gewohnheit den 1. parameter als lhs angenommen und ohne nachzudenken wurde dann this zum rhs.

dumm von mir

C Newbie

Wenn schon const-correctnes dann auch richtig:

const Foo operator+(Foo const& a,Foo const& b)
{
  Foo temp(a);
  temp+=b;
  return temp;
}

Michael E.

Eine lokale Variable darf doch eh nicht verändert ewrden oder seh ich da was falsch?

hm...irgendwie bekomm ich das nich hin!
Also die operatoren ausserhalb der klasse?

Wenn ja, wie greife ich auf die private objekte zu? (also mein charzeiger)?

BasicMan01

Schau dir mal das Schlüsselwort friend an, dies ermöglicht es dir auch auf private Elemente außerhalb der Klasse zuzugreifen.

http://www.cpp-tutor.de/cpp/le12/le12_04.htm#logisch

PS: Warum hat es hier solange gedauert, bis mal jemand auf die eigentliche Frage von Man.bloed eingegangen ist?

danke....
nun habe ich aber gehört...friend soll man nicht nehmen?

groovemaster

Shade Of Mine schrieb:

das mit b+a war ein Fehler von mir hab nicht genau nachgedacht und nach sturer gewohnheit den 1. parameter als lhs angenommen und ohne nachzudenken wurde dann this zum rhs.

Gebs zu, du hast absichtlich 2 pitfalls eingebaut.

Man.bloed schrieb:

nun habe ich aber gehört...friend soll man nicht nehmen?

Keine Ahnungen wo du das gehört hast. Aber da hat der Autor sicher etwas übertrieben. Natürlich sollte man friend mit Bedacht verwenden, aber vollkommen darauf zu verzichten, ist Unsinn. Gerade bei solchen Operatoren sind sie hilfreich, und du brichst damit ja auch nicht den bestehenden Klassenschutz.

C Newbie

Michael E. schrieb:

Eine lokale Variable darf doch eh nicht verändert ewrden oder seh ich da was falsch?

Minimal Beispiel:

class Foo
{
public:
	Foo(): a_(0) {}
	Foo(int a): a_(a) {}

	Foo& operator+=(Foo const& a)
	{
		this->a_ += a.a_;
		return *this;
	}	

private:
	int a_;
};

Foo operator+(Foo const& a, Foo const& b)
{
	Foo temp(a);
	temp+=b;
	return temp;
}

int main()
{
    Foo a(1), b(2), c(3);

    a + b = c; // geht

    int  d(1), e(2), f(3);

    d + e = f; // geht nicht!!
}

Alleine schon um den gleichen Effekt wie bei den Ints zu haben, sollte man den Rückgabewert const machen.